Add multi-model tagging and SHUCK3R-style classifier UX.

Persist WD/ML tagger choice, harden selected-tag assignment with a noise floor, and restyle the SPA for clearer settings, run progress, and review.

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

README.md

@@ -105,16 +105,23 @@ The frontend automatically falls back to local mock mode when backend requests f
 
 ## GPU Acceleration
 
-Inference attempts to use ONNX Runtime CUDA provider when available. If CUDA/cuDNN dependencies are missing, runtime falls back to CPU and logs provider errors.
+Inference uses ONNX Runtime CUDA when the pip CUDA/cuDNN wheels are installed and discoverable.
 
-### Verify GPU visibility
+```bash
+pip install -r backend/requirements.txt
+# includes: onnxruntime-gpu[cuda,cudnn]==1.26.0
+```
+
+On Windows the API prepends `site-packages/nvidia/*/bin` to the DLL search path before creating sessions. Without that, ORT may *list* CUDA then fall back to CPU on the first Conv.
+
+### Verify GPU is actually usable
 
 ```bash
 curl http://127.0.0.1:8000/health/providers
 curl http://127.0.0.1:8000/api/providers
 ```
 
-`likely_device: "gpu"` means CUDA provider is visible and CPU is not being force-disabled.
+Look for `"cuda_usable": true`, `"likely_device": "gpu"`, and `active_providers` containing `CUDAExecutionProvider`. Listing CUDA alone is not enough.
 
 ### Runtime controls
 

backend/app/api.py

@@ -31,13 +31,16 @@ from .services import (
     extract_scores,
     extract_scores_batch,
     extract_scores_with_experimental_media,
+    global_top_tags,
     is_experimental_media,
     load_known_tags,
     migrate_file,
+    normalize_tag_name,
     resolve_settings,
     sanitize_folder_name,
     scan_images,
 )
+from .providers import clear_provider_probe_cache, probe_execution_providers
 from .storage import execute, fetch_all, fetch_one, from_json, to_json
 
 router = APIRouter(prefix="/api")
@@ -67,11 +70,17 @@ class _ImageInferenceResult:
     inference_failed: bool
 
 
+def _assignment_noise_floor(confidence_threshold: float) -> float:
+    return max(0.15, float(confidence_threshold) * 0.5)
+
+
 def _now_iso() -> str:
     return datetime.now(timezone.utc).isoformat()
 
 
-def _get_max_inference_workers() -> int:
+def _get_max_inference_workers(settings_workers: int | None = None) -> int:
+    if settings_workers is not None:
+        return max(1, min(int(settings_workers), 16))
     raw = os.getenv("MAX_INFERENCE_WORKERS", "2").strip()
     try:
         value = int(raw)
@@ -81,16 +90,19 @@ def _get_max_inference_workers() -> int:
 
 
 def _get_inference_mode() -> str:
-    raw = os.getenv("INFERENCE_MODE", "batch").strip().lower()
+    raw = os.getenv("INFERENCE_MODE", "single").strip().lower()
     return "single" if raw == "single" else "batch"
 
 
-def _get_inference_batch_size() -> int:
-    raw = os.getenv("INFERENCE_BATCH_SIZE", "8").strip()
+def _get_inference_batch_size(settings_batch: int | None = None) -> int:
+    # Default 1: imgutils cannot true-batch; small batches keep workers saturated.
+    if settings_batch is not None:
+        return max(1, min(int(settings_batch), 64))
+    raw = os.getenv("INFERENCE_BATCH_SIZE", "1").strip()
     try:
         value = int(raw)
     except ValueError:
-        value = 8
+        value = 1
     return max(1, min(value, 64))
 
 
@@ -127,37 +139,82 @@ def _is_provider_related_error(err: Exception) -> bool:
     return any(k in msg for k in keywords)
 
 
+def _classify_from_scores(
+    image_path: Path,
+    scores: dict[str, float],
+    matched_tags: set[str],
+    confidence_threshold: float,
+) -> _ImageInferenceResult:
+    primary_tag, primary_score, secondary = choose_best_tags(scores, matched_tags)
+    needs_review = False
+    reason = None
+    if not scores:
+        return _ImageInferenceResult(
+            image_path=image_path,
+            scores=scores,
+            primary_tag=None,
+            primary_score=None,
+            secondary=[],
+            needs_review=True,
+            reason="Inference returned no tag scores for this image.",
+            inference_failed=True,
+        )
+    if primary_tag is None:
+        needs_review = True
+        reason = "No matching tags found among selected tags."
+    elif primary_score is not None:
+        noise_floor = _assignment_noise_floor(confidence_threshold)
+        if primary_score < noise_floor:
+            needs_review = True
+            reason = (
+                f"Below noise floor ({primary_score:.3f} < {noise_floor:.3f}); "
+                "no reliable selected-tag match."
+            )
+            secondary = [{"tag": primary_tag, "score": float(primary_score)}, *secondary][:4]
+            primary_tag = None
+            primary_score = None
+        elif primary_score < confidence_threshold:
+            needs_review = True
+            reason = f"Below threshold ({primary_score:.3f} < {confidence_threshold:.3f})."
+            # Weak selected-tag winners are suggestions only — do not present as the label.
+            secondary = [{"tag": primary_tag, "score": float(primary_score)}, *secondary][:4]
+            primary_tag = None
+            primary_score = None
+    return _ImageInferenceResult(
+        image_path=image_path,
+        scores=scores,
+        primary_tag=primary_tag,
+        primary_score=primary_score,
+        secondary=secondary,
+        needs_review=needs_review,
+        reason=reason,
+        inference_failed=False,
+    )
+
+
 def _infer_one_image(
     image_path: Path,
     matched_tags: set[str],
     confidence_threshold: float,
     experimental_media_enabled: bool = False,
+    tagger_model: str = "wd_swinv2_v3",
+    wd_general_threshold: float = 0.35,
 ) -> _ImageInferenceResult:
     try:
         if experimental_media_enabled and is_experimental_media(image_path):
-            scores = extract_scores_with_experimental_media(image_path, experimental_media_enabled)
+            scores = extract_scores_with_experimental_media(
+                image_path,
+                experimental_media_enabled,
+                tagger_model=tagger_model,
+                wd_general_threshold=wd_general_threshold,
+            )
         else:
-            # Keep base path unchanged so existing mocks/tests and behavior remain stable.
-            scores = extract_scores(image_path)
-        primary_tag, primary_score, secondary = choose_best_tags(scores, matched_tags)
-        needs_review = False
-        reason = None
-        if primary_tag is None:
-            needs_review = True
-            reason = "No matching tags found in selected folders."
-        elif primary_score is not None and primary_score < confidence_threshold:
-            needs_review = True
-            reason = f"Below threshold ({primary_score:.3f} < {confidence_threshold:.3f})."
-        return _ImageInferenceResult(
-            image_path=image_path,
-            scores=scores,
-            primary_tag=primary_tag,
-            primary_score=primary_score,
-            secondary=secondary,
-            needs_review=needs_review,
-            reason=reason,
-            inference_failed=False,
-        )
+            scores = extract_scores(
+                image_path,
+                tagger_model=tagger_model,
+                wd_general_threshold=wd_general_threshold,
+            )
+        return _classify_from_scores(image_path, scores, matched_tags, confidence_threshold)
     except Exception as err:
         if _is_provider_related_error(err):
             logger.exception("inference_provider_failure image=%s", image_path)
@@ -181,6 +238,8 @@ def _infer_batch_with_fallback(
     confidence_threshold: float,
     requested_mode: str,
     experimental_media_enabled: bool = False,
+    tagger_model: str = "wd_swinv2_v3",
+    wd_general_threshold: float = 0.35,
 ) -> tuple[list[_ImageInferenceResult], float, str]:
     if not image_paths:
         return [], 0.0, "none"
@@ -189,7 +248,12 @@ def _infer_batch_with_fallback(
         start = time.perf_counter()
         rows = [
             _infer_one_image(
-                image_paths[0], matched_tags, confidence_threshold, experimental_media_enabled
+                image_paths[0],
+                matched_tags,
+                confidence_threshold,
+                experimental_media_enabled,
+                tagger_model,
+                wd_general_threshold,
             )
         ]
         elapsed_ms = (time.perf_counter() - start) * 1000.0
@@ -200,7 +264,14 @@ def _infer_batch_with_fallback(
     if any(is_experimental_media(p) for p in image_paths):
         start = time.perf_counter()
         rows = [
-            _infer_one_image(p, matched_tags, confidence_threshold, experimental_media_enabled)
+            _infer_one_image(
+                p,
+                matched_tags,
+                confidence_threshold,
+                experimental_media_enabled,
+                tagger_model,
+                wd_general_threshold,
+            )
             for p in image_paths
         ]
         elapsed_ms = (time.perf_counter() - start) * 1000.0
@@ -208,32 +279,17 @@ def _infer_batch_with_fallback(
 
     start = time.perf_counter()
     try:
-        scores_by_image = extract_scores_batch(image_paths)
+        scores_by_image = extract_scores_batch(
+            image_paths,
+            tagger_model=tagger_model,
+            wd_general_threshold=wd_general_threshold,
+        )
         if len(scores_by_image) != len(image_paths):
             raise RuntimeError("Batch inference result count mismatch")
-        rows: list[_ImageInferenceResult] = []
-        for image_path, scores in zip(image_paths, scores_by_image):
-            primary_tag, primary_score, secondary = choose_best_tags(scores, matched_tags)
-            needs_review = False
-            reason = None
-            if primary_tag is None:
-                needs_review = True
-                reason = "No matching tags found in selected folders."
-            elif primary_score is not None and primary_score < confidence_threshold:
-                needs_review = True
-                reason = f"Below threshold ({primary_score:.3f} < {confidence_threshold:.3f})."
-            rows.append(
-                _ImageInferenceResult(
-                    image_path=image_path,
-                    scores=scores,
-                    primary_tag=primary_tag,
-                    primary_score=primary_score,
-                    secondary=secondary,
-                    needs_review=needs_review,
-                    reason=reason,
-                    inference_failed=False,
-                )
-            )
+        rows = [
+            _classify_from_scores(image_path, scores, matched_tags, confidence_threshold)
+            for image_path, scores in zip(image_paths, scores_by_image)
+        ]
         elapsed_ms = (time.perf_counter() - start) * 1000.0
         return rows, elapsed_ms, "batch"
     except Exception as err:
@@ -249,6 +305,8 @@ def _infer_batch_with_fallback(
                 confidence_threshold,
                 "batch",
                 experimental_media_enabled,
+                tagger_model,
+                wd_general_threshold,
             )
             right_rows, right_ms, _ = _infer_batch_with_fallback(
                 image_paths[mid:],
@@ -256,10 +314,17 @@ def _infer_batch_with_fallback(
                 confidence_threshold,
                 "batch",
                 experimental_media_enabled,
+                tagger_model,
+                wd_general_threshold,
             )
             return left_rows + right_rows, left_ms + right_ms, "batch_fallback"
         row = _infer_one_image(
-            image_paths[0], matched_tags, confidence_threshold, experimental_media_enabled
+            image_paths[0],
+            matched_tags,
+            confidence_threshold,
+            experimental_media_enabled,
+            tagger_model,
+            wd_general_threshold,
         )
         elapsed_ms = (time.perf_counter() - start) * 1000.0
         return [row], elapsed_ms, "single_fallback"
@@ -269,6 +334,14 @@ def _settings_from_db() -> AppSettings:
     row = fetch_one("SELECT * FROM settings WHERE id = 1")
     if not row:
         return AppSettings()
+    selected_raw = row.get("selected_tags_json") or "[]"
+    selected_tags = from_json(selected_raw, default=[])
+    if not isinstance(selected_tags, list):
+        selected_tags = []
+    selected_tags = [str(t).strip() for t in selected_tags if str(t).strip()]
+    tagger_model = str(row.get("tagger_model") or "wd_swinv2_v3").strip()
+    if tagger_model not in {"ml_danbooru", "wd_swinv2_v3", "wd_eva02_large"}:
+        tagger_model = "wd_swinv2_v3"
     return AppSettings(
         root_repo=row["root_repo"],
         categories_root=row["categories_root"],
@@ -276,10 +349,30 @@ def _settings_from_db() -> AppSettings:
         default_migrate_mode=row["default_migrate_mode"],
         scan_recursive=bool(row.get("scan_recursive", 1)),
         experimental_media_enabled=bool(row.get("experimental_media_enabled", 0)),
+        selected_tags=selected_tags,
+        max_inference_workers=int(row.get("max_inference_workers") or 2),
+        inference_batch_size=int(row.get("inference_batch_size") or 1),
+        force_cpu_inference=bool(row.get("force_cpu_inference", 0)),
+        tagger_model=tagger_model,  # type: ignore[arg-type]
+        wd_general_threshold=float(row.get("wd_general_threshold") or 0.35),
     )
 
 
+def _apply_runtime_inference_env(settings: AppSettings) -> None:
+    """Mirror persisted settings into env knobs used by the run executor."""
+    os.environ["MAX_INFERENCE_WORKERS"] = str(settings.max_inference_workers)
+    os.environ["INFERENCE_BATCH_SIZE"] = str(settings.inference_batch_size)
+    if settings.force_cpu_inference:
+        os.environ["FORCE_CPU_INFERENCE"] = "true"
+    else:
+        os.environ.pop("FORCE_CPU_INFERENCE", None)
+    clear_provider_probe_cache()
+
+
 def _item_from_row(row: dict, include_full_scores: bool = False) -> ClassifiedItem:
+    scores = from_json(row.get("full_scores_json") or "{}", default={})
+    if not isinstance(scores, dict):
+        scores = {}
     return ClassifiedItem(
         id=row["id"],
         run_id=row["run_id"],
@@ -288,11 +381,8 @@ def _item_from_row(row: dict, include_full_scores: bool = False) -> ClassifiedIt
         primary_tag=row["primary_tag"],
         primary_score=row["primary_score"],
         secondary_suggestions=from_json(row.get("secondary_json") or "[]", default=[]),
-        full_scores=(
-            from_json(row.get("full_scores_json") or "{}", default={})
-            if include_full_scores
-            else None
-        ),
+        global_top_tags=global_top_tags({str(k): float(v) for k, v in scores.items()}),
+        full_scores=scores if include_full_scores else None,
         suggested_destination=row["suggested_destination"],
         final_tag=row["final_tag"],
         final_destination=row["final_destination"],
@@ -326,6 +416,7 @@ def _run_status_from_row(row: dict) -> RunStatusResponse:
         batch_size=telemetry.get("batch_size"),
         avg_infer_ms_per_image=telemetry.get("avg_infer_ms_per_image"),
         queue_seed=telemetry.get("queue_seed"),
+        tagger_model=row.get("tagger_model"),
     )
 
 
@@ -349,8 +440,14 @@ def _execute_run(
     matched_tags: set[str],
     scan_recursive: bool = True,
     experimental_media_enabled: bool = False,
+    max_inference_workers: int = 2,
+    inference_batch_size: int = 1,
+    tagger_model: str = "wd_swinv2_v3",
+    wd_general_threshold: float = 0.35,
 ) -> None:
     try:
+        provider_state = probe_execution_providers()
+        logger.info("run_provider_state run_id=%d state=%s", run_id, provider_state)
         execute(
             "UPDATE runs SET status = 'running', started_at = ?, last_error = NULL WHERE id = ?",
             (_now_iso(), run_id),
@@ -380,7 +477,8 @@ def _execute_run(
             rng = random.Random(queue_seed)
             rng.shuffle(ordered_paths)
         inference_mode = _get_inference_mode()
-        configured_batch_size = _get_inference_batch_size()
+        configured_batch_size = _get_inference_batch_size(inference_batch_size)
+        # Prefer single-image tasks so worker pool stays saturated (no true ORT batch).
         batch_size = 1 if inference_mode == "single" else configured_batch_size
         _set_run_telemetry(
             run_id,
@@ -403,12 +501,13 @@ def _execute_run(
         cancelled = False
         infer_elapsed_ms_total = 0.0
         infer_sample_count = 0
-        max_workers = _get_max_inference_workers()
+        max_workers = _get_max_inference_workers(max_inference_workers)
         logger.info(
-            "run_inference_workers run_id=%d workers=%d total_images=%d",
+            "run_inference_workers run_id=%d workers=%d total_images=%d device=%s",
             run_id,
             max_workers,
             scan_output.stats.eligible_images,
+            provider_state.get("likely_device"),
         )
 
         with ThreadPoolExecutor(max_workers=max_workers, thread_name_prefix="infer") as executor:
@@ -432,6 +531,8 @@ def _execute_run(
                         confidence_threshold,
                         inference_mode,
                         experimental_media_enabled,
+                        tagger_model,
+                        wd_general_threshold,
                     )
                     pending[future] = next_batch
 
@@ -544,12 +645,25 @@ def get_settings() -> AppSettings:
 
 @router.put("/settings", response_model=AppSettings)
 def save_settings(payload: SaveSettingsRequest) -> AppSettings:
+    known = load_known_tags(TAGS_CSV)
+    known_by_norm = {normalize_tag_name(t): t for t in known}
+    cleaned_tags: list[str] = []
+    for tag in payload.selected_tags:
+        value = tag.strip()
+        if not value:
+            continue
+        matched = value if value in known else known_by_norm.get(normalize_tag_name(value))
+        if matched and matched not in cleaned_tags:
+            cleaned_tags.append(matched)
+    payload.selected_tags = cleaned_tags
     try:
         execute(
             """
             UPDATE settings
             SET root_repo = ?, categories_root = ?, confidence_threshold = ?,
-                default_migrate_mode = ?, scan_recursive = ?, experimental_media_enabled = ?
+                default_migrate_mode = ?, scan_recursive = ?, experimental_media_enabled = ?,
+                selected_tags_json = ?, max_inference_workers = ?, inference_batch_size = ?,
+                force_cpu_inference = ?, tagger_model = ?, wd_general_threshold = ?
             WHERE id = 1
             """,
             (
@@ -559,11 +673,18 @@ def save_settings(payload: SaveSettingsRequest) -> AppSettings:
                 payload.default_migrate_mode,
                 1 if payload.scan_recursive else 0,
                 1 if payload.experimental_media_enabled else 0,
+                to_json(cleaned_tags),
+                int(payload.max_inference_workers),
+                int(payload.inference_batch_size),
+                1 if payload.force_cpu_inference else 0,
+                payload.tagger_model,
+                float(payload.wd_general_threshold),
             ),
         )
     except Exception:
         logger.exception("failed to save settings")
         raise HTTPException(status_code=500, detail="Failed to persist settings")
+    _apply_runtime_inference_env(payload)
     return payload
 
 
@@ -606,34 +727,22 @@ def scan_preview() -> dict:
 
 @router.get("/providers")
 def get_providers() -> dict[str, object]:
-    force_cpu = os.getenv("FORCE_CPU_INFERENCE", "").strip().lower() in {"1", "true", "yes", "on"}
-    try:
-        import onnxruntime as ort
-
-        providers = list(ort.get_available_providers())
-        cuda_available = "CUDAExecutionProvider" in providers
-        return {
-            "available_providers": providers,
-            "cuda_available": cuda_available,
-            "cpu_available": "CPUExecutionProvider" in providers,
-            "forced_cpu": force_cpu,
-            "likely_device": "cpu" if force_cpu else ("gpu" if cuda_available else "cpu"),
-        }
-    except Exception as err:
-        return {
-            "available_providers": [],
-            "cuda_available": False,
-            "cpu_available": True,
-            "forced_cpu": force_cpu,
-            "likely_device": "cpu",
-            "error": str(err),
-        }
+    settings = _settings_from_db()
+    _apply_runtime_inference_env(settings)
+    info = probe_execution_providers()
+    info["tagger_model"] = settings.tagger_model
+    info["note"] = (
+        "CUDA usability reflects ORT GPU runtime readiness; "
+        "the active tagger model is selected separately in settings."
+    )
+    return info
 
 
 @router.post("/runs/start", response_model=StartRunResponse)
 def start_run(payload: StartRunRequest) -> StartRunResponse:
     logger.info("run_start_requested")
     current = _settings_from_db()
+    _apply_runtime_inference_env(current)
     resolved = resolve_settings(
         current, payload.root_repo, payload.categories_root, payload.confidence_threshold
     )
@@ -643,12 +752,19 @@ def start_run(payload: StartRunRequest) -> StartRunResponse:
     if not resolved.root_repo or not resolved.categories_root:
         raise HTTPException(status_code=400, detail="root_repo and categories_root are required")
 
+    selected_folders = payload.selected_folders
+    if not selected_folders:
+        selected_folders = list(current.selected_tags)
+
     try:
         known_tags = load_known_tags(TAGS_CSV)
-        mappings = discover_tag_folders(categories_root, known_tags, payload.selected_folders)
+        mappings = discover_tag_folders(categories_root, known_tags, selected_folders)
         matched_tags = {m.matched_tag for m in mappings if m.matched and m.matched_tag}
         if not matched_tags:
-            raise HTTPException(status_code=400, detail="No folder names map to known tags")
+            raise HTTPException(
+                status_code=400,
+                detail="No selected tags map to known tags.csv entries. Save tags in settings first.",
+            )
     except HTTPException:
         raise
     except Exception:
@@ -660,10 +776,15 @@ def start_run(payload: StartRunRequest) -> StartRunResponse:
             """
             INSERT INTO runs (
                 root_repo, categories_root, confidence_threshold, status,
-                total_images, processed_images, failed_images, cancel_requested
-            ) VALUES (?, ?, ?, 'pending', 0, 0, 0, 0)
+                total_images, processed_images, failed_images, cancel_requested, tagger_model
+            ) VALUES (?, ?, ?, 'pending', 0, 0, 0, 0, ?)
             """,
-            (str(root_repo), str(categories_root), resolved.confidence_threshold),
+            (
+                str(root_repo),
+                str(categories_root),
+                resolved.confidence_threshold,
+                current.tagger_model,
+            ),
         )
     except Exception:
         logger.exception("failed to create run row")
@@ -671,8 +792,19 @@ def start_run(payload: StartRunRequest) -> StartRunResponse:
 
     worker = threading.Thread(
         target=_execute_run,
-        args=(run_id, root_repo, categories_root, resolved.confidence_threshold, matched_tags,
-              resolved.scan_recursive, resolved.experimental_media_enabled),
+        args=(
+            run_id,
+            root_repo,
+            categories_root,
+            resolved.confidence_threshold,
+            matched_tags,
+            resolved.scan_recursive,
+            resolved.experimental_media_enabled,
+            current.max_inference_workers,
+            current.inference_batch_size,
+            current.tagger_model,
+            current.wd_general_threshold,
+        ),
         daemon=True,
     )
     worker.start()

backend/app/main.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-import os
 import time
 
 from fastapi import FastAPI
@@ -9,6 +8,7 @@ from fastapi import Request
 from fastapi.middleware.cors import CORSMiddleware
 
 from .api import router
+from .providers import clear_provider_probe_cache, preload_onnx_runtime_dlls, probe_execution_providers
 from .storage import init_db
 
 app = FastAPI(title="Image Classifier Workflow API", version="0.1.0")
@@ -31,28 +31,7 @@ def _configure_logging() -> None:
 
 
 def _get_provider_snapshot() -> dict[str, object]:
-    force_cpu = os.getenv("FORCE_CPU_INFERENCE", "").strip().lower() in {"1", "true", "yes", "on"}
-    try:
-        import onnxruntime as ort
-
-        providers = list(ort.get_available_providers())
-        cuda_available = "CUDAExecutionProvider" in providers
-        return {
-            "available_providers": providers,
-            "cuda_available": cuda_available,
-            "cpu_available": "CPUExecutionProvider" in providers,
-            "forced_cpu": force_cpu,
-            "likely_device": "cpu" if force_cpu else ("gpu" if cuda_available else "cpu"),
-        }
-    except Exception as err:
-        return {
-            "available_providers": [],
-            "cuda_available": False,
-            "cpu_available": True,
-            "forced_cpu": force_cpu,
-            "likely_device": "cpu",
-            "error": str(err),
-        }
+    return probe_execution_providers()
 
 
 @app.middleware("http")
@@ -83,6 +62,8 @@ async def log_requests(request: Request, call_next):
 @app.on_event("startup")
 def startup() -> None:
     _configure_logging()
+    preload_onnx_runtime_dlls()
+    clear_provider_probe_cache()
     provider_state = _get_provider_snapshot()
     logger.info("onnx_provider_state state=%s", provider_state)
     logger.info("initializing database at startup")

backend/app/providers.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import logging
+import os
+import sys
+from functools import lru_cache
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+_DLL_DIRS_CONFIGURED = False
+
+
+def _nvidia_bin_dirs() -> list[Path]:
+    try:
+        import onnxruntime as ort
+
+        site_packages = Path(ort.__file__).resolve().parents[1]
+    except Exception:
+        site_packages = Path(sys.prefix) / "Lib" / "site-packages"
+    nvidia_root = site_packages / "nvidia"
+    if not nvidia_root.is_dir():
+        return []
+    return sorted(p for p in nvidia_root.glob("*/bin") if p.is_dir())
+
+
+def ensure_nvidia_dll_search_path() -> list[str]:
+    """
+    Make pip-bundled CUDA/cuDNN DLLs discoverable on Windows.
+
+    ort.preload_dlls() alone is not always enough for cudnn_engines_* libs;
+    without PATH / add_dll_directory, Conv ops fall back to CPU at runtime.
+    """
+    global _DLL_DIRS_CONFIGURED
+    bin_dirs = [str(p.resolve()) for p in _nvidia_bin_dirs()]
+    if not bin_dirs:
+        return []
+
+    path_parts = os.environ.get("PATH", "").split(os.pathsep) if os.environ.get("PATH") else []
+    # Prepend missing bins so the loader finds them first.
+    for d in reversed(bin_dirs):
+        if d not in path_parts:
+            path_parts.insert(0, d)
+    os.environ["PATH"] = os.pathsep.join(path_parts)
+
+    if hasattr(os, "add_dll_directory"):
+        for d in bin_dirs:
+            try:
+                os.add_dll_directory(d)
+            except (FileNotFoundError, OSError):
+                logger.warning("add_dll_directory failed for %s", d)
+
+    if not _DLL_DIRS_CONFIGURED:
+        logger.info("nvidia_dll_dirs configured count=%d dirs=%s", len(bin_dirs), bin_dirs)
+        _DLL_DIRS_CONFIGURED = True
+    return bin_dirs
+
+
+def preload_onnx_runtime_dlls() -> None:
+    """Load pip-bundled CUDA/cuDNN DLLs before creating ORT sessions."""
+    ensure_nvidia_dll_search_path()
+    try:
+        import onnxruntime as ort
+
+        if hasattr(ort, "preload_dlls"):
+            ort.preload_dlls()
+            logger.info("onnxruntime preload_dlls completed")
+    except Exception:
+        logger.exception("onnxruntime preload_dlls failed")
+
+
+def _force_cpu() -> bool:
+    return os.getenv("FORCE_CPU_INFERENCE", "").strip().lower() in {"1", "true", "yes", "on"}
+
+
+def _find_probe_model() -> Path | None:
+    hub = Path.home() / ".cache" / "huggingface" / "hub"
+    matches = sorted(hub.glob("models--deepghs--ml-danbooru-onnx/**/*.onnx"))
+    return matches[0] if matches else None
+
+
+@lru_cache(maxsize=1)
+def probe_execution_providers() -> dict[str, object]:
+    """
+    Probe *active* providers by creating a real ORT session and running it.
+
+    Listing CUDAExecutionProvider is not enough — Windows often lists it even when
+    CUDA/cuDNN DLLs fail during Conv execution and ORT silently falls back to CPU.
+
+    Note: CUDA usability is independent of which tagger model is selected in settings
+    (ML-Danbooru vs WD14 variants); both share the same ORT runtime path.
+    """
+    force_cpu = _force_cpu()
+    result: dict[str, object] = {
+        "available_providers": [],
+        "active_providers": [],
+        "cuda_available": False,
+        "cuda_usable": False,
+        "cpu_available": True,
+        "forced_cpu": force_cpu,
+        "likely_device": "cpu",
+        "provider_error": None,
+        "ort_version": None,
+        "nvidia_dll_dirs": [],
+    }
+    try:
+        import numpy as np
+        import onnxruntime as ort
+
+        result["nvidia_dll_dirs"] = ensure_nvidia_dll_search_path()
+        preload_onnx_runtime_dlls()
+        result["ort_version"] = ort.__version__
+        available = list(ort.get_available_providers())
+        result["available_providers"] = available
+        result["cuda_available"] = "CUDAExecutionProvider" in available
+        result["cpu_available"] = "CPUExecutionProvider" in available
+
+        if force_cpu:
+            result["likely_device"] = "cpu"
+            result["active_providers"] = ["CPUExecutionProvider"]
+            return result
+
+        model_path = _find_probe_model()
+        if model_path is None:
+            result["likely_device"] = "gpu" if result["cuda_available"] else "cpu"
+            result["provider_error"] = (
+                "No cached ML-Danbooru ONNX model found to verify CUDA; "
+                "run one tagging pass to download it."
+            )
+            return result
+
+        requested = (
+            ["CUDAExecutionProvider", "CPUExecutionProvider"]
+            if result["cuda_available"]
+            else ["CPUExecutionProvider"]
+        )
+        session = ort.InferenceSession(str(model_path), providers=requested)
+        active = list(session.get_providers())
+        result["active_providers"] = active
+
+        # Execute a real forward pass — session creation can claim CUDA while Conv fails.
+        if "CUDAExecutionProvider" in active:
+            inputs = session.get_inputs()[0]
+            shape = []
+            for dim in inputs.shape:
+                if isinstance(dim, int) and dim > 0:
+                    shape.append(dim)
+                else:
+                    shape.append(1 if len(shape) == 0 else 448)
+            # Model expects NCHW float; use 1x3x448x448 when dynamic.
+            if len(shape) != 4:
+                shape = [1, 3, 448, 448]
+            feed = {inputs.name: np.zeros(shape, dtype=np.float32)}
+            try:
+                session.run(None, feed)
+                result["cuda_usable"] = True
+            except Exception as run_err:
+                result["cuda_usable"] = False
+                result["provider_error"] = (
+                    "CUDAExecutionProvider loaded but inference failed "
+                    f"(cuDNN/runtime). Falling back to CPU. Detail: {run_err}"
+                )
+                logger.warning("provider_probe_cuda_run_failed error=%s", run_err)
+        else:
+            result["cuda_usable"] = False
+            if result["cuda_available"]:
+                result["provider_error"] = (
+                    "CUDAExecutionProvider is listed but failed to initialize; "
+                    "sessions are using CPU. Ensure onnxruntime-gpu[cuda,cudnn] "
+                    "DLLs are installed and restart the API."
+                )
+
+        result["likely_device"] = "gpu" if result["cuda_usable"] else "cpu"
+        if result["cuda_usable"]:
+            logger.info("provider_probe_ok active=%s model=%s", active, model_path)
+        return result
+    except Exception as err:
+        logger.exception("provider_probe_failed")
+        result["provider_error"] = str(err)
+        result["likely_device"] = "cpu"
+        return result
+
+
+def clear_provider_probe_cache() -> None:
+    probe_execution_providers.cache_clear()

backend/app/schemas.py

@@ -8,6 +8,7 @@ from pydantic import BaseModel, Field
 ItemStatus = Literal["proposed", "reviewed", "approved", "rejected", "migrated"]
 MigrateMode = Literal["move", "copy"]
 RunLifecycleStatus = Literal["pending", "running", "completed", "failed", "cancelled"]
+TaggerModel = Literal["ml_danbooru", "wd_swinv2_v3", "wd_eva02_large"]
 
 
 class AppSettings(BaseModel):
@@ -17,6 +18,14 @@ class AppSettings(BaseModel):
     default_migrate_mode: MigrateMode = "copy"
     scan_recursive: bool = True
     experimental_media_enabled: bool = False
+    # Shuck3r-style persisted preferences (survive reload / restart).
+    selected_tags: list[str] = Field(default_factory=list)
+    # Shared ORT session is serialized; >2 workers mostly queues behind the lock.
+    max_inference_workers: int = Field(default=2, ge=1, le=16)
+    inference_batch_size: int = Field(default=1, ge=1, le=64)
+    force_cpu_inference: bool = False
+    tagger_model: TaggerModel = "wd_swinv2_v3"
+    wd_general_threshold: float = Field(default=0.35, ge=0.0, le=1.0)
 
 
 class SaveSettingsRequest(AppSettings):
@@ -58,6 +67,7 @@ class ClassifiedItem(BaseModel):
     primary_tag: str | None
     primary_score: float | None
     secondary_suggestions: list[SecondarySuggestion] = Field(default_factory=list)
+    global_top_tags: list[SecondarySuggestion] = Field(default_factory=list)
     full_scores: dict[str, float] | None = None
     suggested_destination: str | None
     final_tag: str | None
@@ -94,6 +104,7 @@ class RunStatusResponse(BaseModel):
     batch_size: int | None = None
     avg_infer_ms_per_image: float | None = None
     queue_seed: int | None = None
+    tagger_model: str | None = None
 
 
 class UpdateItemRequest(BaseModel):

backend/app/services.py

@@ -5,6 +5,7 @@ import logging
 import subprocess
 import shutil
 import tempfile
+import threading
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -26,6 +27,9 @@ VIDEO_EXTENSIONS = {
 logger = logging.getLogger(__name__)
 _BATCH_INFERENCE_SUPPORTED: bool | None = None
 _WINDOWS_FORBIDDEN_CHARS = set('<>:"/\\|?*')
+# imgutils keeps one shared ORT session; concurrent Run() calls under GPU load
+# corrupt outputs (empty score dicts) and thrash VRAM. Serialize model execution.
+_INFERENCE_LOCK = threading.Lock()
 
 
 def normalize_tag_name(value: str) -> str:
@@ -213,24 +217,21 @@ def scan_images(
     )
 
 
-def extract_scores(image_path: Path) -> dict[str, float]:
-    from imgutils.tagging import get_mldanbooru_tags
+TAGGER_MODEL_ML = "ml_danbooru"
+TAGGER_MODEL_WD_SWINV2 = "wd_swinv2_v3"
+TAGGER_MODEL_WD_EVA02 = "wd_eva02_large"
+WD_MODEL_NAMES = {
+    TAGGER_MODEL_WD_SWINV2: "SwinV2_v3",
+    TAGGER_MODEL_WD_EVA02: "EVA02_Large",
+}
 
-    raw = get_mldanbooru_tags(
-        str(image_path),
-        threshold=0.0,
-        size=448,
-        keep_ratio=True,
-        drop_overlap=False,
-        use_real_name=False,
-    )
 
+def _parse_mldanbooru_raw(raw: object) -> dict[str, float]:
     scores: dict[str, float] = {}
     if isinstance(raw, dict):
         for tag, score in raw.items():
             scores[str(tag)] = float(score)
         return scores
-
     if isinstance(raw, list):
         for item in raw:
             if isinstance(item, (list, tuple)) and len(item) >= 2:
@@ -238,46 +239,161 @@ def extract_scores(image_path: Path) -> dict[str, float]:
     return scores
 
 
-def _extract_scores_from_pil_image(image: Image.Image) -> dict[str, float]:
+def _normalize_score_tags(scores: dict[str, float]) -> dict[str, float]:
+    """Normalize tag keys to underscore form so they match tags.csv / selected tags."""
+    normalized: dict[str, float] = {}
+    for tag, score in scores.items():
+        key = normalize_tag_name(str(tag))
+        if not key:
+            continue
+        current = normalized.get(key)
+        if current is None or float(score) > current:
+            normalized[key] = float(score)
+    return normalized
+
+
+def _parse_wd14_raw(raw: object) -> dict[str, float]:
+    scores: dict[str, float] = {}
+    if isinstance(raw, dict):
+        for tag, score in raw.items():
+            scores[str(tag)] = float(score)
+        return _normalize_score_tags(scores)
+    if isinstance(raw, (list, tuple)):
+        # fmt tuple returns ordered parts; flatten dict parts only.
+        for part in raw:
+            if isinstance(part, dict):
+                for tag, score in part.items():
+                    scores[str(tag)] = float(score)
+        return _normalize_score_tags(scores)
+    return {}
+
+
+def _run_mldanbooru(image: Path | Image.Image | str) -> dict[str, float]:
     from imgutils.tagging import get_mldanbooru_tags
 
     raw = get_mldanbooru_tags(
-        image,
+        image if isinstance(image, Image.Image) else str(image),
         threshold=0.0,
         size=448,
         keep_ratio=True,
         drop_overlap=False,
         use_real_name=False,
     )
+    return _normalize_score_tags(_parse_mldanbooru_raw(raw))
 
-    scores: dict[str, float] = {}
-    if isinstance(raw, dict):
-        for tag, score in raw.items():
-            scores[str(tag)] = float(score)
-        return scores
 
-    if isinstance(raw, list):
-        for item in raw:
-            if isinstance(item, (list, tuple)) and len(item) >= 2:
-                scores[str(item[0])] = float(item[1])
+def _run_wd14(
+    image: Path | Image.Image | str,
+    *,
+    model_name: str,
+    general_threshold: float,
+) -> dict[str, float]:
+    from imgutils.tagging import get_wd14_tags
+
+    raw = get_wd14_tags(
+        image if isinstance(image, Image.Image) else str(image),
+        model_name=model_name,
+        general_threshold=general_threshold,
+        no_underline=False,
+        drop_overlap=False,
+        fmt="general",
+    )
+    return _parse_wd14_raw(raw)
+
+
+def extract_scores(
+    image_path: Path,
+    *,
+    tagger_model: str = TAGGER_MODEL_WD_SWINV2,
+    wd_general_threshold: float = 0.35,
+) -> dict[str, float]:
+    from .providers import ensure_nvidia_dll_search_path, preload_onnx_runtime_dlls
+
+    ensure_nvidia_dll_search_path()
+    preload_onnx_runtime_dlls()
+
+    with _INFERENCE_LOCK:
+        scores = _extract_scores_unlocked(
+            image_path,
+            tagger_model=tagger_model,
+            wd_general_threshold=wd_general_threshold,
+        )
+        # One retry: concurrent/GPU glitches occasionally return an empty map.
+        if not scores:
+            logger.warning(
+                "empty_scores_retry path=%s tagger_model=%s", image_path, tagger_model
+            )
+            scores = _extract_scores_unlocked(
+                image_path,
+                tagger_model=tagger_model,
+                wd_general_threshold=wd_general_threshold,
+            )
     return scores
 
 
+def _extract_scores_unlocked(
+    image: Path | Image.Image | str,
+    *,
+    tagger_model: str,
+    wd_general_threshold: float,
+) -> dict[str, float]:
+    if tagger_model == TAGGER_MODEL_ML:
+        return _run_mldanbooru(image)
+    wd_name = WD_MODEL_NAMES.get(tagger_model)
+    if wd_name is None:
+        raise ValueError(f"Unsupported tagger_model: {tagger_model}")
+    return _run_wd14(
+        image,
+        model_name=wd_name,
+        general_threshold=wd_general_threshold,
+    )
+
+
+def _extract_scores_from_pil_image(
+    image: Image.Image,
+    *,
+    tagger_model: str = TAGGER_MODEL_WD_SWINV2,
+    wd_general_threshold: float = 0.35,
+) -> dict[str, float]:
+    from .providers import ensure_nvidia_dll_search_path, preload_onnx_runtime_dlls
+
+    ensure_nvidia_dll_search_path()
+    preload_onnx_runtime_dlls()
+    with _INFERENCE_LOCK:
+        return _extract_scores_unlocked(
+            image,
+            tagger_model=tagger_model,
+            wd_general_threshold=wd_general_threshold,
+        )
+
+
 def extract_scores_with_experimental_media(
-    image_path: Path, experimental_media_enabled: bool = False
+    image_path: Path,
+    experimental_media_enabled: bool = False,
+    *,
+    tagger_model: str = TAGGER_MODEL_WD_SWINV2,
+    wd_general_threshold: float = 0.35,
 ) -> dict[str, float]:
     """
     Experimental path: supports GIF/video by sampling a representative frame.
     """
     if not experimental_media_enabled or not is_experimental_media(image_path):
-        return extract_scores(image_path)
+        return extract_scores(
+            image_path,
+            tagger_model=tagger_model,
+            wd_general_threshold=wd_general_threshold,
+        )
 
     ext = image_path.suffix.lower()
     if ext == ".gif":
         with Image.open(image_path) as gif:
             gif.seek(0)
             frame = gif.convert("RGB")
-            return _extract_scores_from_pil_image(frame)
+            return _extract_scores_from_pil_image(
+                frame,
+                tagger_model=tagger_model,
+                wd_general_threshold=wd_general_threshold,
+            )
 
     # Video path: extract first frame with ffmpeg to a temporary image.
     with tempfile.TemporaryDirectory(prefix="media_frame_") as temp_dir:
@@ -297,58 +413,46 @@ def extract_scores_with_experimental_media(
         if result.returncode != 0 or not frame_path.exists():
             err = (result.stderr or result.stdout or "").strip()
             raise RuntimeError(f"Video frame extraction failed: {err or 'ffmpeg unavailable'}")
-        return extract_scores(frame_path)
+        return extract_scores(
+            frame_path,
+            tagger_model=tagger_model,
+            wd_general_threshold=wd_general_threshold,
+        )
+
 
+def extract_scores_batch(
+    image_paths: list[Path],
+    *,
+    tagger_model: str = TAGGER_MODEL_WD_SWINV2,
+    wd_general_threshold: float = 0.35,
+) -> list[dict[str, float]]:
+    """
+    imgutils taggers do not accept image lists.
 
-def extract_scores_batch(image_paths: list[Path]) -> list[dict[str, float]]:
+    Fall back to sequential per-image scoring; the run executor provides
+    parallelism across workers (avoid nested pools on a shared ORT session).
+    """
     if not image_paths:
         return []
-    global _BATCH_INFERENCE_SUPPORTED
-
-    if _BATCH_INFERENCE_SUPPORTED is False:
-        return [extract_scores(p) for p in image_paths]
 
-    from imgutils.tagging import get_mldanbooru_tags
-
-    try:
-        raw = get_mldanbooru_tags(
-            [str(p) for p in image_paths],
-            threshold=0.0,
-            size=448,
-            keep_ratio=True,
-            drop_overlap=False,
-            use_real_name=False,
+    global _BATCH_INFERENCE_SUPPORTED
+    if _BATCH_INFERENCE_SUPPORTED is not False:
+        logger.info("batch list API unsupported by imgutils; using per-image inference")
+        _BATCH_INFERENCE_SUPPORTED = False
+
+    return [
+        extract_scores(
+            path,
+            tagger_model=tagger_model,
+            wd_general_threshold=wd_general_threshold,
         )
-    except TypeError as err:
-        # Current imgutils build treats list input as invalid image type.
-        if "Unknown image type" in str(err):
-            if _BATCH_INFERENCE_SUPPORTED is not False:
-                logger.warning("batch inference not supported by imgutils; using per-image fallback")
-            _BATCH_INFERENCE_SUPPORTED = False
-            return [extract_scores(p) for p in image_paths]
-        raise
-
-    parsed: list[dict[str, float]] = []
-    if isinstance(raw, list) and len(raw) == len(image_paths):
-        _BATCH_INFERENCE_SUPPORTED = True
-        for entry in raw:
-            if isinstance(entry, dict):
-                parsed.append({str(k): float(v) for k, v in entry.items()})
-                continue
-            if isinstance(entry, list):
-                scores: dict[str, float] = {}
-                for item in entry:
-                    if isinstance(item, (list, tuple)) and len(item) >= 2:
-                        scores[str(item[0])] = float(item[1])
-                parsed.append(scores)
-                continue
-            raise TypeError("Unexpected batch inference entry format")
-        return parsed
+        for path in image_paths
+    ]
 
-    # If the backend or library returns an unexpected shape, fall back to per-image inference.
-    logger.warning("batch inference unsupported format; falling back to per-image path")
-    _BATCH_INFERENCE_SUPPORTED = False
-    return [extract_scores(p) for p in image_paths]
+
+def global_top_tags(scores: dict[str, float], limit: int = 5) -> list[dict[str, float]]:
+    ranked = sorted(scores.items(), key=lambda item: item[1], reverse=True)[:limit]
+    return [{"tag": tag, "score": float(score)} for tag, score in ranked]
 
 
 def choose_best_tags(
@@ -423,13 +527,16 @@ def resolve_settings(
     categories_root: str | None,
     confidence_threshold: float | None,
 ) -> AppSettings:
-    return AppSettings(
-        root_repo=root_repo if root_repo is not None else current.root_repo,
-        categories_root=categories_root if categories_root is not None else current.categories_root,
-        confidence_threshold=(
-            confidence_threshold if confidence_threshold is not None else current.confidence_threshold
-        ),
-        default_migrate_mode=current.default_migrate_mode,
-        scan_recursive=current.scan_recursive,
-        experimental_media_enabled=current.experimental_media_enabled,
+    return current.model_copy(
+        update={
+            "root_repo": root_repo if root_repo is not None else current.root_repo,
+            "categories_root": (
+                categories_root if categories_root is not None else current.categories_root
+            ),
+            "confidence_threshold": (
+                confidence_threshold
+                if confidence_threshold is not None
+                else current.confidence_threshold
+            ),
+        }
     )

backend/app/storage.py

@@ -81,6 +81,12 @@ def _ensure_settings_columns(conn: sqlite3.Connection) -> None:
     expected_columns = {
         "scan_recursive": "INTEGER NOT NULL DEFAULT 1",
         "experimental_media_enabled": "INTEGER NOT NULL DEFAULT 0",
+        "selected_tags_json": "TEXT NOT NULL DEFAULT '[]'",
+        "max_inference_workers": "INTEGER NOT NULL DEFAULT 2",
+        "inference_batch_size": "INTEGER NOT NULL DEFAULT 1",
+        "force_cpu_inference": "INTEGER NOT NULL DEFAULT 0",
+        "tagger_model": "TEXT NOT NULL DEFAULT 'wd_swinv2_v3'",
+        "wd_general_threshold": "REAL NOT NULL DEFAULT 0.35",
     }
     rows = conn.execute("PRAGMA table_info(settings)").fetchall()
     existing = {row[1] for row in rows}
@@ -99,6 +105,7 @@ def _ensure_runs_columns(conn: sqlite3.Connection) -> None:
         "finished_at": "TEXT",
         "last_error": "TEXT",
         "cancel_requested": "INTEGER NOT NULL DEFAULT 0",
+        "tagger_model": "TEXT NOT NULL DEFAULT 'wd_swinv2_v3'",
     }
     rows = conn.execute("PRAGMA table_info(runs)").fetchall()
     existing = {row[1] for row in rows}

backend/requirements.txt

@@ -2,4 +2,5 @@ fastapi==0.116.1
 uvicorn==0.35.0
 pydantic==2.11.7
 dghs-imgutils==0.19.0
+onnxruntime-gpu[cuda,cudnn]==1.26.0
 pytest==8.4.1

backend/tests/test_api_run_progress.py

@@ -5,6 +5,7 @@ from pathlib import Path
 
 from fastapi.testclient import TestClient
 
+from app.api import _classify_from_scores
 from app.main import app
 from app.schemas import FolderMapping, ScanStats
 from app.services import ScanOutput
@@ -20,6 +21,119 @@ def test_providers_endpoint_shape():
         assert "likely_device" in payload
         assert "cuda_available" in payload
         assert "forced_cpu" in payload
+        assert "tagger_model" in payload
+        assert "note" in payload
+
+
+def test_settings_round_trip_includes_tagger_model(tmp_path: Path):
+    with TestClient(app) as client:
+        payload = {
+            "root_repo": str(tmp_path / "root"),
+            "categories_root": str(tmp_path / "cats"),
+            "confidence_threshold": 0.55,
+            "default_migrate_mode": "copy",
+            "scan_recursive": True,
+            "experimental_media_enabled": False,
+            "selected_tags": [],
+            "max_inference_workers": 2,
+            "inference_batch_size": 1,
+            "force_cpu_inference": False,
+            "tagger_model": "wd_eva02_large",
+            "wd_general_threshold": 0.4,
+        }
+        put_resp = client.put("/api/settings", json=payload)
+        put_resp.raise_for_status()
+        saved = put_resp.json()
+        assert saved["tagger_model"] == "wd_eva02_large"
+        assert saved["wd_general_threshold"] == 0.4
+        get_resp = client.get("/api/settings")
+        get_resp.raise_for_status()
+        loaded = get_resp.json()
+        assert loaded["tagger_model"] == "wd_eva02_large"
+        assert loaded["wd_general_threshold"] == 0.4
+        assert loaded["max_inference_workers"] == 2
+
+
+def test_below_threshold_null_primary_and_global_top_tags(monkeypatch, tmp_path: Path):
+    root = tmp_path / "root_thresh"
+    cats = tmp_path / "cats_thresh"
+    root.mkdir()
+    cats.mkdir()
+    (cats / "loli").mkdir()
+    file_path = root / "weak.jpg"
+    file_path.write_text("fake", encoding="utf-8")
+
+    def fake_scan_images(_root, **kwargs):
+        return ScanOutput(
+            image_paths=[file_path],
+            stats=ScanStats(
+                total_files=1,
+                eligible_images=1,
+                ignored_unsupported=0,
+                ignored_gif=0,
+                failed_to_read=0,
+            ),
+        )
+
+    monkeypatch.setattr("app.api.scan_images", fake_scan_images)
+    monkeypatch.setattr(
+        "app.api.extract_scores",
+        lambda *_a, **_k: {
+            "1girl": 0.97,
+            "solo": 0.9,
+            "loli": 0.27,
+        },
+    )
+    monkeypatch.setattr("app.api.load_known_tags", lambda _p: {"loli", "1girl", "solo"})
+    monkeypatch.setattr(
+        "app.api.discover_tag_folders",
+        lambda _root, _tags, _selected: [
+            FolderMapping(
+                folder_name="loli", normalized_name="loli", matched_tag="loli", matched=True
+            )
+        ],
+    )
+
+    with TestClient(app) as client:
+        start_resp = client.post(
+            "/api/runs/start",
+            json={
+                "root_repo": str(root),
+                "categories_root": str(cats),
+                "confidence_threshold": 0.6,
+                "selected_folders": ["loli"],
+            },
+        )
+        start_resp.raise_for_status()
+        run_id = start_resp.json()["run_id"]
+        final = _wait_for_status(client, run_id, {"completed", "failed", "cancelled"})
+        assert final is not None
+        assert final["status"] == "completed"
+        assert final.get("tagger_model")
+        items_resp = client.get(f"/api/runs/{run_id}/items")
+        items_resp.raise_for_status()
+        items = items_resp.json()
+        assert len(items) == 1
+        item = items[0]
+        assert item["primary_tag"] is None
+        assert item["needs_review"] is True
+        assert item["secondary_suggestions"]
+        assert item["secondary_suggestions"][0]["tag"] == "loli"
+        tops = [t["tag"] for t in item["global_top_tags"]]
+        assert tops[:2] == ["1girl", "solo"]
+
+
+def test_classify_noise_floor_clears_weak_primary(tmp_path: Path):
+    result = _classify_from_scores(
+        tmp_path / "x.jpg",
+        {"loli": 0.2, "1girl": 0.95},
+        {"loli"},
+        confidence_threshold=0.6,
+    )
+    assert result.primary_tag is None
+    assert result.needs_review is True
+    assert "noise floor" in (result.reason or "").lower()
+    assert result.secondary[0]["tag"] == "loli"
 
 
 def _wait_for_status(client: TestClient, run_id: int, terminal: set[str], timeout_s: float = 5.0):
@@ -58,7 +172,7 @@ def test_run_progress_reaches_completed(monkeypatch, tmp_path: Path):
         )
 
     monkeypatch.setattr("app.api.scan_images", fake_scan_images)
-    monkeypatch.setattr("app.api.extract_scores", lambda _p: {"1girl": 0.91})
+    monkeypatch.setattr("app.api.extract_scores", lambda *_a, **_k: {"1girl": 0.91})
     monkeypatch.setattr("app.api.load_known_tags", lambda _p: {"1girl"})
     monkeypatch.setattr(
         "app.api.discover_tag_folders",
@@ -116,7 +230,7 @@ def test_item_preview_returns_image(monkeypatch, tmp_path: Path):
         )
 
     monkeypatch.setattr("app.api.scan_images", fake_scan_images)
-    monkeypatch.setattr("app.api.extract_scores", lambda _p: {"1girl": 0.92})
+    monkeypatch.setattr("app.api.extract_scores", lambda *_a, **_k: {"1girl": 0.92})
     monkeypatch.setattr("app.api.load_known_tags", lambda _p: {"1girl"})
     monkeypatch.setattr(
         "app.api.discover_tag_folders",
@@ -177,7 +291,7 @@ def test_selected_tag_wins_when_global_top_not_selected(monkeypatch, tmp_path: P
     monkeypatch.setattr("app.api.scan_images", fake_scan_images)
     monkeypatch.setattr(
         "app.api.extract_scores",
-        lambda _p: {"1girl": 0.99, "monster_girl": 0.85, "slime_girl": 0.82},
+        lambda *_a, **_k: {"1girl": 0.99, "monster_girl": 0.85, "slime_girl": 0.82},
     )
     monkeypatch.setattr("app.api.load_known_tags", lambda _p: {"1girl", "monster_girl", "slime_girl"})
     monkeypatch.setattr(
@@ -243,7 +357,7 @@ def test_item_scores_debug_endpoint(monkeypatch, tmp_path: Path):
         )
 
     monkeypatch.setattr("app.api.scan_images", fake_scan_images)
-    monkeypatch.setattr("app.api.extract_scores", lambda _p: {"1girl": 0.92, "solo": 0.88})
+    monkeypatch.setattr("app.api.extract_scores", lambda *_a, **_k: {"1girl": 0.92, "solo": 0.88})
     monkeypatch.setattr("app.api.load_known_tags", lambda _p: {"1girl", "solo"})
     monkeypatch.setattr(
         "app.api.discover_tag_folders",
@@ -305,7 +419,7 @@ def test_run_cancel_sets_cancelled(monkeypatch, tmp_path: Path):
             ),
         )
 
-    def slow_scores(_p):
+    def slow_scores(_p, **_kwargs):
         time.sleep(0.03)
         return {"1girl": 0.88}
 
@@ -377,7 +491,7 @@ def test_seeded_queue_shuffle_is_deterministic(monkeypatch, tmp_path: Path):
             ),
         )
 
-    def record_scores(path: Path):
+    def record_scores(path: Path, **_kwargs):
         observed_order.append(path.name)
         return {"1girl": 0.88}
 
@@ -465,12 +579,12 @@ def test_batch_mode_falls_back_to_single(monkeypatch, tmp_path: Path):
             ),
         )
 
-    def fail_batch(_paths):
+    def fail_batch(_paths, **_kwargs):
         raise RuntimeError("synthetic batch failure")
 
     monkeypatch.setattr("app.api.scan_images", fake_scan_images)
     monkeypatch.setattr("app.api.extract_scores_batch", fail_batch)
-    monkeypatch.setattr("app.api.extract_scores", lambda _p: {"1girl": 0.9})
+    monkeypatch.setattr("app.api.extract_scores", lambda *_a, **_k: {"1girl": 0.9})
     monkeypatch.setattr("app.api.load_known_tags", lambda _p: {"1girl"})
     monkeypatch.setattr(
         "app.api.discover_tag_folders",

backend/tests/test_services.py

@@ -3,9 +3,14 @@ from pathlib import Path
 from PIL import Image
 
 from app.services import (
+    TAGGER_MODEL_ML,
+    TAGGER_MODEL_WD_EVA02,
+    TAGGER_MODEL_WD_SWINV2,
     choose_best_tags,
     discover_tag_folders,
     ensure_collision_free_destination,
+    extract_scores,
+    global_top_tags,
     migrate_file,
     normalize_tag_name,
     sanitize_folder_name,
@@ -169,6 +174,73 @@ def test_choose_best_tags_matches_normalized_selected_tags() -> None:
     assert secondary == [{"tag": "slime_girl", "score": 0.84}]
 
 
+def test_global_top_tags_orders_by_score() -> None:
+    tops = global_top_tags({"a": 0.1, "b": 0.9, "c": 0.5}, limit=2)
+    assert tops == [{"tag": "b", "score": 0.9}, {"tag": "c", "score": 0.5}]
+
+
+def test_extract_scores_routes_ml_danbooru(monkeypatch, tmp_path: Path) -> None:
+    import app.services as services
+
+    calls: list[str] = []
+
+    monkeypatch.setattr("app.providers.ensure_nvidia_dll_search_path", lambda: [])
+    monkeypatch.setattr("app.providers.preload_onnx_runtime_dlls", lambda: None)
+    monkeypatch.setattr(
+        services,
+        "_run_mldanbooru",
+        lambda _image: calls.append("ml") or {"1girl": 0.9, "black_hair": 0.8},
+    )
+    monkeypatch.setattr(
+        services,
+        "_run_wd14",
+        lambda *_a, **_k: calls.append("wd") or {"solo": 0.7},
+    )
+
+    img = tmp_path / "x.jpg"
+    img.write_text("x", encoding="utf-8")
+    scores = extract_scores(img, tagger_model=TAGGER_MODEL_ML)
+    assert calls == ["ml"]
+    assert scores["1girl"] == 0.9
+    assert scores["black_hair"] == 0.8
+
+
+def test_extract_scores_routes_wd_models(monkeypatch, tmp_path: Path) -> None:
+    import app.services as services
+
+    seen: list[tuple[str, float]] = []
+
+    def fake_wd(image, *, model_name: str, general_threshold: float):
+        seen.append((model_name, general_threshold))
+        return {"solo": 0.66, "long_hair": 0.55}
+
+    monkeypatch.setattr("app.providers.ensure_nvidia_dll_search_path", lambda: [])
+    monkeypatch.setattr("app.providers.preload_onnx_runtime_dlls", lambda: None)
+    monkeypatch.setattr(services, "_run_mldanbooru", lambda _image: {"nope": 1.0})
+    monkeypatch.setattr(services, "_run_wd14", fake_wd)
+
+    img = tmp_path / "y.jpg"
+    img.write_text("y", encoding="utf-8")
+
+    scores = extract_scores(
+        img, tagger_model=TAGGER_MODEL_WD_SWINV2, wd_general_threshold=0.41
+    )
+    assert seen[-1] == ("SwinV2_v3", 0.41)
+    assert scores["solo"] == 0.66
+    assert scores["long_hair"] == 0.55
+
+    extract_scores(img, tagger_model=TAGGER_MODEL_WD_EVA02, wd_general_threshold=0.2)
+    assert seen[-1] == ("EVA02_Large", 0.2)
+
+
+def test_normalize_score_tags_collapses_space_forms() -> None:
+    from app.services import _normalize_score_tags
+
+    scores = _normalize_score_tags({"Black Hair": 0.8, "black_hair": 0.9, "solo": 0.5})
+    assert scores["black_hair"] == 0.9
+    assert scores["solo"] == 0.5
+
+
 def test_migrate_file_copy_with_collision_suffix(tmp_path: Path) -> None:
     src = tmp_path / "sample.jpg"
     src.write_text("abc", encoding="utf-8")

frontend/index.html

@@ -3,7 +3,13 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Image Classifier Workflow</title>
+    <title>Image Classifier</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=Figtree:wght@400;500;600;700&family=Fraunces:opsz,wght@9..144,500;9..144,700&display=swap"
+      rel="stylesheet"
+    />
   </head>
   <body>
     <div id="root"></div>

frontend/src/App.jsx

@@ -8,11 +8,51 @@ const DEFAULT_SETTINGS = {
   default_migrate_mode: "copy",
   scan_recursive: true,
   experimental_media_enabled: false,
+  selected_tags: [],
+  max_inference_workers: 2,
+  inference_batch_size: 1,
+  force_cpu_inference: false,
+  tagger_model: "wd_swinv2_v3",
+  wd_general_threshold: 0.35,
 };
+
+const TAGGER_MODELS = [
+  {
+    id: "ml_danbooru",
+    label: "ML-Danbooru",
+    help: "Original ONNX tagger used by this app. Fast baseline.",
+  },
+  {
+    id: "wd_swinv2_v3",
+    label: "WD SwinV2 v3",
+    help: "Recommended default — strong general-tag accuracy on anime art.",
+  },
+  {
+    id: "wd_eva02_large",
+    label: "WD EVA02 Large",
+    help: "Largest WD tagger; slower, often slightly more accurate.",
+  },
+];
+
 const ACTIVE_RUN_STORAGE_KEY = "imageClassifierActiveRunId";
 
+function settingsSnapshot(settings, selectedTags) {
+  return JSON.stringify({
+    ...settings,
+    selected_tags: selectedTags,
+  });
+}
+
+function formatTagScore(entry) {
+  if (!entry) return "";
+  return `${entry.tag} (${Number(entry.score).toFixed(3)})`;
+}
+
 function App() {
   const [settings, setSettings] = useState(DEFAULT_SETTINGS);
+  const [savedSnapshot, setSavedSnapshot] = useState(
+    settingsSnapshot(DEFAULT_SETTINGS, [])
+  );
   const [offlineMode, setOfflineMode] = useState(false);
   const [runId, setRunId] = useState(null);
   const [runStatus, setRunStatus] = useState(null);
@@ -31,6 +71,8 @@ function App() {
   const [scoreDebugByItem, setScoreDebugByItem] = useState({});
   const [scoreLoadingByItem, setScoreLoadingByItem] = useState({});
   const [finalTagDrafts, setFinalTagDrafts] = useState({});
+  const [scanPreview, setScanPreview] = useState(null);
+  const [scanPreviewLoading, setScanPreviewLoading] = useState(false);
   const [opsLoading, setOpsLoading] = useState({
     saving: false,
     startingRun: false,
@@ -40,6 +82,18 @@ function App() {
   });
   const finalTagTimersRef = useRef({});
   const pollTimerRef = useRef(null);
+  const tagsHydratedRef = useRef(false);
+  const skipNextTagPersistRef = useRef(false);
+
+  const isDirty = useMemo(
+    () => settingsSnapshot(settings, selectedTags) !== savedSnapshot,
+    [settings, selectedTags, savedSnapshot]
+  );
+
+  const isWdModel = String(settings.tagger_model || "").startsWith("wd_");
+  const runActive = Boolean(
+    runStatus && ["pending", "running"].includes(runStatus.status)
+  );
 
   async function refreshItems(currentRunId) {
     if (!currentRunId) return;
@@ -57,10 +111,17 @@ function App() {
   }
 
   useEffect(() => {
-    api.getSettings()
+    api
+      .getSettings()
       .then((data) => {
-        setSettings(data);
+        const merged = { ...DEFAULT_SETTINGS, ...data };
+        const tags = Array.isArray(data.selected_tags) ? data.selected_tags : [];
+        setSettings(merged);
+        skipNextTagPersistRef.current = true;
+        setSelectedTags(tags);
+        tagsHydratedRef.current = true;
         setMigrateMode(data.default_migrate_mode || "copy");
+        setSavedSnapshot(settingsSnapshot(merged, tags));
         setOfflineMode(api.isOfflineMode());
       })
       .catch((err) => setError(err.message));
@@ -68,15 +129,46 @@ function App() {
     if (storedRunId > 0) {
       setRunId(storedRunId);
     }
-    api.getProviders()
+    api
+      .getProviders()
       .then((info) => setProviderInfo(info))
       .catch(() => setProviderInfo(null));
   }, []);
 
+  // Persist typed/selected tags (Shuck3r-style preference survival across reloads).
+  useEffect(() => {
+    if (!tagsHydratedRef.current) return;
+    if (skipNextTagPersistRef.current) {
+      skipNextTagPersistRef.current = false;
+      return;
+    }
+    if (!Array.isArray(selectedTags)) return;
+    const timer = setTimeout(() => {
+      const next = { ...settings, selected_tags: selectedTags };
+      setSettings(next);
+      api
+        .saveSettings(next)
+        .then((saved) => {
+          const merged = { ...DEFAULT_SETTINGS, ...saved };
+          setSettings(merged);
+          setSavedSnapshot(
+            settingsSnapshot(merged, Array.isArray(saved.selected_tags) ? saved.selected_tags : selectedTags)
+          );
+        })
+        .catch(() => {
+          /* ignore transient save errors while typing */
+        });
+    }, 400);
+    return () => clearTimeout(timer);
+    // Intentionally depend on selectedTags only to avoid save loops from settings edits.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [selectedTags]);
+
   useEffect(() => {
     let cancelled = false;
     const timer = setTimeout(() => {
-      api.getTags(tagQuery, 50)
+      api
+        .getTags(tagQuery, 50)
         .then((data) => {
           if (cancelled) return;
           setTagOptions(data.items || []);
@@ -155,14 +247,23 @@ function App() {
   }, [runId]);
 
   async function handleSaveSettings(e) {
-    e.preventDefault();
+    if (e) e.preventDefault();
     setLoading(true);
     setOpsLoading((prev) => ({ ...prev, saving: true }));
     setError("");
     try {
-      const saved = await api.saveSettings(settings);
-      setSettings(saved);
+      const saved = await api.saveSettings({ ...settings, selected_tags: selectedTags });
+      const merged = { ...DEFAULT_SETTINGS, ...saved };
+      setSettings(merged);
+      const tags = Array.isArray(saved.selected_tags) ? saved.selected_tags : selectedTags;
+      if (Array.isArray(saved.selected_tags)) {
+        skipNextTagPersistRef.current = true;
+        setSelectedTags(saved.selected_tags);
+      }
+      setSavedSnapshot(settingsSnapshot(merged, tags));
       setOfflineMode(api.isOfflineMode());
+      const providers = await api.getProviders();
+      setProviderInfo(providers);
     } catch (err) {
       setError(err.message);
     } finally {
@@ -171,11 +272,31 @@ function App() {
     }
   }
 
+  async function handlePreviewScan() {
+    setScanPreviewLoading(true);
+    setError("");
+    try {
+      if (isDirty) {
+        await handleSaveSettings();
+      }
+      const preview = await api.previewScan();
+      setScanPreview(preview);
+    } catch (err) {
+      setError(err.message);
+      setScanPreview(null);
+    } finally {
+      setScanPreviewLoading(false);
+    }
+  }
+
   async function handleStartRun() {
     setLoading(true);
     setOpsLoading((prev) => ({ ...prev, startingRun: true }));
     setError("");
     try {
+      if (isDirty) {
+        await handleSaveSettings();
+      }
       const result = await api.startRun({
         ...settings,
         selected_folders: selectedTags.length > 0 ? selectedTags : null,
@@ -191,6 +312,7 @@ function App() {
         failed_images: 0,
         progress_pct: 0,
         cancel_requested: false,
+        tagger_model: settings.tagger_model,
       });
     } catch (err) {
       setError(err.message);
@@ -315,13 +437,11 @@ function App() {
     if (!value) return;
     if (selectedTags.includes(value)) return;
 
-    // Fast path when current dropdown options already include the tag.
     if (tagOptions.includes(value)) {
       addSelectedTag(value);
       return;
     }
 
-    // Validate against backend tag index to avoid accidental typo tags.
     const result = await api.getTags(value, 200);
     if ((result.items || []).includes(value)) {
       addSelectedTag(value);
@@ -349,95 +469,256 @@ function App() {
 
   return (
     <div className="container">
-      <h1>Image Classifier Workflow</h1>
-      <p>
-        Configure source + category roots, run tagging, review predictions, then approve and
-        migrate using move/copy.
-      </p>
+      <header className="app-header">
+        <h1>Image Classifier</h1>
+        <p className="lede">
+          Configure paths and tagger model, select destination tags, run inference, then review
+          and migrate.
+        </p>
+        {providerInfo && !offlineMode && (
+          <div className="provider-strip">
+            <span>
+              Device: <strong>{providerInfo.likely_device || "unknown"}</strong>
+            </span>
+            <span>
+              CUDA: <strong>{String(Boolean(providerInfo.cuda_usable))}</strong>
+            </span>
+            <span>
+              Active: <strong>{(providerInfo.active_providers || []).join(", ") || "n/a"}</strong>
+            </span>
+            <span>
+              Tagger: <strong>{providerInfo.tagger_model || settings.tagger_model}</strong>
+            </span>
+            <span>
+              Forced CPU: <strong>{String(Boolean(providerInfo.forced_cpu))}</strong>
+            </span>
+          </div>
+        )}
+      </header>
+
       {offlineMode && (
         <div className="error">
           Backend is offline. Running in browser-only demo mode with local mock data.
         </div>
       )}
-      {providerInfo && !offlineMode && (
-        <div className="stats">
-          <span>Inference device: {providerInfo.likely_device || "unknown"}</span>
-          <span>CUDA available: {String(Boolean(providerInfo.cuda_available))}</span>
-          <span>Forced CPU: {String(Boolean(providerInfo.forced_cpu))}</span>
-        </div>
+      {providerInfo?.provider_error && !offlineMode && (
+        <div className="error">{providerInfo.provider_error}</div>
       )}
-
       {error && <div className="error">{error}</div>}
 
-      <section className="card">
-        <h2>Configuration</h2>
-        <form onSubmit={handleSaveSettings} className="grid">
-          <label>
-            Root Repository
-            <input
-              value={settings.root_repo}
-              onChange={(e) => setSettings({ ...settings, root_repo: e.target.value })}
-            />
-          </label>
-          <label>
-            Categories Root
-            <input
-              value={settings.categories_root}
-              onChange={(e) => setSettings({ ...settings, categories_root: e.target.value })}
-            />
-          </label>
-          <label>
-            Confidence Threshold
-            <input
-              type="number"
-              step="0.01"
-              min="0"
-              max="1"
-              value={settings.confidence_threshold}
-              onChange={(e) =>
-                setSettings({ ...settings, confidence_threshold: Number(e.target.value) })
-              }
-            />
-          </label>
-          <label>
-            Default Migrate Mode
-            <select
-              value={settings.default_migrate_mode}
-              onChange={(e) => setSettings({ ...settings, default_migrate_mode: e.target.value })}
-            >
-              <option value="copy">copy</option>
-              <option value="move">move</option>
-            </select>
-          </label>
-          <label style={{ flexDirection: "row", alignItems: "center", gap: "0.5rem" }}>
-            <input
-              type="checkbox"
-              checked={Boolean(settings.scan_recursive)}
-              onChange={(e) => setSettings({ ...settings, scan_recursive: e.target.checked })}
-            />
-            Scan subfolders recursively
-          </label>
-          <label style={{ flexDirection: "row", alignItems: "center", gap: "0.5rem" }}>
-            <input
-              type="checkbox"
-              checked={Boolean(settings.experimental_media_enabled)}
-              onChange={(e) =>
-                setSettings({ ...settings, experimental_media_enabled: e.target.checked })
-              }
-            />
-            Experimental: classify GIF/videos using sampled frames
-          </label>
-          <button disabled={loading || opsLoading.saving}>Save Settings</button>
+      <section className="panel">
+        <h2>Settings</h2>
+        <span className="kicker">Paths, model, thresholds, and performance. Save before runs.</span>
+        <form onSubmit={handleSaveSettings}>
+          <fieldset className="settings-section">
+            <legend>Paths &amp; scan</legend>
+            <div className="grid">
+              <label>
+                Root repository
+                <input
+                  value={settings.root_repo}
+                  onChange={(e) => setSettings({ ...settings, root_repo: e.target.value })}
+                  placeholder="Folder of unsorted images"
+                />
+              </label>
+              <label>
+                Categories root
+                <input
+                  value={settings.categories_root}
+                  onChange={(e) => setSettings({ ...settings, categories_root: e.target.value })}
+                  placeholder="Destination folders root (not tags.csv)"
+                />
+              </label>
+              <label>
+                Default migrate mode
+                <select
+                  value={settings.default_migrate_mode}
+                  onChange={(e) =>
+                    setSettings({ ...settings, default_migrate_mode: e.target.value })
+                  }
+                >
+                  <option value="copy">copy</option>
+                  <option value="move">move</option>
+                </select>
+              </label>
+              <label className="inline-check">
+                <input
+                  type="checkbox"
+                  checked={Boolean(settings.scan_recursive)}
+                  onChange={(e) => setSettings({ ...settings, scan_recursive: e.target.checked })}
+                />
+                Scan subfolders recursively
+              </label>
+            </div>
+            <div className="actions">
+              <button
+                type="button"
+                className="secondary"
+                disabled={scanPreviewLoading}
+                onClick={handlePreviewScan}
+              >
+                {scanPreviewLoading ? "Scanning…" : "Preview scan"}
+              </button>
+            </div>
+            {scanPreview?.stats && (
+              <div className="scan-preview">
+                Eligible: {scanPreview.stats.eligible_images} · Total files:{" "}
+                {scanPreview.stats.total_files} · Ignored GIF: {scanPreview.stats.ignored_gif} ·
+                Unsupported: {scanPreview.stats.ignored_unsupported}
+              </div>
+            )}
+          </fieldset>
+
+          <fieldset className="settings-section">
+            <legend>Tagger model</legend>
+            <div className="model-options">
+              {TAGGER_MODELS.map((model) => (
+                <label key={model.id} className="model-option">
+                  <input
+                    type="radio"
+                    name="tagger_model"
+                    value={model.id}
+                    checked={settings.tagger_model === model.id}
+                    onChange={() => setSettings({ ...settings, tagger_model: model.id })}
+                  />
+                  <span>
+                    <strong>{model.label}</strong>
+                    <span>{model.help}</span>
+                  </span>
+                </label>
+              ))}
+            </div>
+          </fieldset>
+
+          <fieldset className="settings-section">
+            <legend>Thresholds</legend>
+            <div className="grid">
+              <label>
+                Assignment confidence
+                <input
+                  type="number"
+                  step="0.01"
+                  min="0"
+                  max="1"
+                  value={settings.confidence_threshold}
+                  onChange={(e) =>
+                    setSettings({ ...settings, confidence_threshold: Number(e.target.value) })
+                  }
+                />
+                <span className="help">
+                  Selected-tag scores below this are suggestions only (no primary assignment).
+                </span>
+              </label>
+              {isWdModel && (
+                <label>
+                  WD general threshold
+                  <input
+                    type="number"
+                    step="0.01"
+                    min="0"
+                    max="1"
+                    value={settings.wd_general_threshold}
+                    onChange={(e) =>
+                      setSettings({
+                        ...settings,
+                        wd_general_threshold: Number(e.target.value),
+                      })
+                    }
+                  />
+                  <span className="help">
+                    WD14 inference cutoff for general tags (default 0.35).
+                  </span>
+                </label>
+              )}
+            </div>
+          </fieldset>
+
+          <fieldset className="settings-section">
+            <legend>Performance</legend>
+            <div className="grid">
+              <label>
+                Max inference workers
+                <input
+                  type="number"
+                  min="1"
+                  max="16"
+                  value={settings.max_inference_workers ?? 2}
+                  onChange={(e) =>
+                    setSettings({
+                      ...settings,
+                      max_inference_workers: Math.max(
+                        1,
+                        Math.min(16, Number(e.target.value) || 1)
+                      ),
+                    })
+                  }
+                />
+                <span className="help">Keep at 2 for GPU ORT sessions (serialized lock).</span>
+              </label>
+              <label>
+                Inference batch size
+                <input
+                  type="number"
+                  min="1"
+                  max="64"
+                  value={settings.inference_batch_size ?? 1}
+                  onChange={(e) =>
+                    setSettings({
+                      ...settings,
+                      inference_batch_size: Math.max(
+                        1,
+                        Math.min(64, Number(e.target.value) || 1)
+                      ),
+                    })
+                  }
+                />
+              </label>
+              <label className="inline-check">
+                <input
+                  type="checkbox"
+                  checked={Boolean(settings.force_cpu_inference)}
+                  onChange={(e) =>
+                    setSettings({ ...settings, force_cpu_inference: e.target.checked })
+                  }
+                />
+                Force CPU inference
+              </label>
+              <label className="inline-check">
+                <input
+                  type="checkbox"
+                  checked={Boolean(settings.experimental_media_enabled)}
+                  onChange={(e) =>
+                    setSettings({ ...settings, experimental_media_enabled: e.target.checked })
+                  }
+                />
+                Experimental: classify GIF/videos via sampled frames
+              </label>
+            </div>
+          </fieldset>
+
+          <div className="sticky-save">
+            <span className={isDirty ? "dirty" : "clean"}>
+              {isDirty ? "Unsaved settings changes" : "Settings saved"}
+            </span>
+            <button type="submit" disabled={loading || opsLoading.saving || !isDirty}>
+              {opsLoading.saving ? "Saving…" : "Save settings"}
+            </button>
+          </div>
         </form>
       </section>
 
-      <section className="card">
-        <h2>Run Classification</h2>
+      <section className="panel">
+        <h2>Tag selection</h2>
+        <span className="kicker">
+          Only these tags compete for folder assignment. Changes auto-save.
+        </span>
         <label>
           Tag match search (from tags.csv)
           <input
             value={tagQuery}
             onChange={(e) => setTagQuery(e.target.value)}
+            list="tag-match-suggestions"
+            autoComplete="off"
             onKeyDown={async (e) => {
               if (e.key === "Enter") {
                 e.preventDefault();
@@ -449,21 +730,40 @@ function App() {
                 }
               }
             }}
-            placeholder="Type to search tags..."
+            placeholder="Type to search tags (e.g. monster_girl)..."
           />
-        </label>
-        <div className="actions">
-          <select defaultValue="" onChange={(e) => addSelectedTag(e.target.value)}>
-            <option value="" disabled>
-              Select matching tag
-            </option>
+          <datalist id="tag-match-suggestions">
             {tagOptions.map((tag) => (
-              <option key={tag} value={tag}>
-                {tag}
-              </option>
+              <option key={tag} value={tag} />
             ))}
-          </select>
+          </datalist>
+        </label>
+        {tagQuery.trim() && (
+          <div className="tag-suggestions">
+            {tagOptions.length === 0 ? (
+              <span className="muted">No matching tags</span>
+            ) : (
+              tagOptions.slice(0, 30).map((tag) => (
+                <button
+                  key={tag}
+                  type="button"
+                  className="tag-suggestion"
+                  onClick={() => {
+                    addSelectedTag(tag);
+                    setTagQuery("");
+                    setError("");
+                  }}
+                >
+                  {tag}
+                </button>
+              ))
+            )}
+          </div>
+        )}
+        <div className="actions">
           <button
+            type="button"
+            className="secondary"
             onClick={async () => {
               setError("");
               try {
@@ -475,77 +775,124 @@ function App() {
           >
             Add typed tag(s)
           </button>
+          <button
+            type="button"
+            disabled={loading || opsLoading.startingRun || runActive}
+            onClick={handleStartRun}
+          >
+            {opsLoading.startingRun ? "Starting…" : "Start run"}
+          </button>
         </div>
         <div className="stats">
-          <span>Selected tags:</span>
-          {selectedTags.length === 0 && <span>none</span>}
-          {selectedTags.map((tag) => (
-            <span key={tag}>
-              {tag} <button onClick={() => removeSelectedTag(tag)}>x</button>
-            </span>
-          ))}
+          {selectedTags.length === 0 ? (
+            <span className="muted">No tags selected</span>
+          ) : (
+            selectedTags.map((tag) => (
+              <span key={tag} className="chip">
+                {tag}
+                <button type="button" onClick={() => removeSelectedTag(tag)} aria-label={`Remove ${tag}`}>
+                  ×
+                </button>
+              </span>
+            ))
+          )}
         </div>
-        <button
-          disabled={
-            loading ||
-            opsLoading.startingRun ||
-            (runStatus && ["pending", "running"].includes(runStatus.status))
-          }
-          onClick={handleStartRun}
-        >
-          Start Run
-        </button>
       </section>
 
-      {runId && (
-        <section className="card">
-          <h2>Review Queue (Run #{runId})</h2>
-          {runStatus && (
-            <div className="stats">
-              <span>Status: {runStatus.status}</span>
+      {runId && runStatus && (
+        <section className="panel">
+          <h2>Run dashboard</h2>
+          <span className="kicker">
+            Run #{runId}
+            {runStatus.tagger_model ? ` · ${runStatus.tagger_model}` : ""}
+          </span>
+          <div className="stats">
+            <div className="metric">
+              <span className="label">Status</span>
+              <span className="value">{runStatus.status}</span>
+            </div>
+            <div className="metric">
+              <span className="label">Total</span>
+              <span className="value">{runStatus.total_images}</span>
+            </div>
+            <div className="metric">
+              <span className="label">Processed</span>
+              <span className="value">{runStatus.processed_images}</span>
+            </div>
+            <div className="metric">
+              <span className="label">Failed</span>
+              <span className="value">{runStatus.failed_images}</span>
+            </div>
+            <div className="metric">
+              <span className="label">Needs review</span>
+              <span className="value">{stats.reviewNeeded}</span>
+            </div>
+            <div className="metric">
+              <span className="label">Progress</span>
+              <span className="value">{Number(runStatus.progress_pct || 0).toFixed(1)}%</span>
+            </div>
+          </div>
+          <div className="progress-track">
+            <div
+              className="progress-fill"
+              style={{ width: `${Math.min(100, Number(runStatus.progress_pct || 0))}%` }}
+            />
+          </div>
+          <div className="stats">
+            {runStatus.avg_infer_ms_per_image != null && (
               <span>
-                Progress: {runStatus.processed_images}/{runStatus.total_images} (
-                {Number(runStatus.progress_pct || 0).toFixed(1)}%)
+                Avg infer: {Number(runStatus.avg_infer_ms_per_image).toFixed(1)} ms/image
               </span>
-              <span>Failed: {runStatus.failed_images}</span>
-              {runStatus.inference_mode && <span>Inference mode: {runStatus.inference_mode}</span>}
-              {runStatus.batch_size ? <span>Batch size: {runStatus.batch_size}</span> : null}
-              {runStatus.avg_infer_ms_per_image !== null &&
-              runStatus.avg_infer_ms_per_image !== undefined ? (
-                <span>
-                  Avg infer ms/image: {Number(runStatus.avg_infer_ms_per_image).toFixed(1)}
-                </span>
-              ) : null}
-              {runStatus.queue_seed !== null && runStatus.queue_seed !== undefined ? (
-                <span>Queue seed: {runStatus.queue_seed}</span>
-              ) : null}
-              {runStatus.cancel_requested && <span>Cancel requested</span>}
-            </div>
-          )}
-          {runStatus && ["pending", "running"].includes(runStatus.status) && (
+            )}
+            {runStatus.inference_mode && <span>Mode: {runStatus.inference_mode}</span>}
+            {runStatus.cancel_requested && <span>Cancel requested</span>}
+          </div>
+          {runActive && (
             <div className="actions">
-              <button onClick={cancelActiveRun}>Cancel Run</button>
+              <button type="button" className="danger" onClick={cancelActiveRun}>
+                Cancel run
+              </button>
             </div>
           )}
+          {runStatus.last_error && <div className="error">{runStatus.last_error}</div>}
+        </section>
+      )}
+
+      {runId && (
+        <section className="panel">
+          <h2>Review</h2>
+          <span className="kicker">
+            Primary is assigned only when a selected tag clears confidence and noise floor.
+            Global tops help spot mis-assignments.
+          </span>
           <div className="stats">
-            <span>Total: {stats.total}</span>
-            <span>Needs Review: {stats.reviewNeeded}</span>
+            <span>Listed: {stats.total}</span>
+            <span>Needs review: {stats.reviewNeeded}</span>
             <span>Approved: {stats.approved}</span>
             <span>Migrated: {stats.migrated}</span>
           </div>
           <div className="actions">
-            <button disabled={opsLoading.applyingBatch} onClick={() => applyBatch("approved")}>
-              Approve Selected
+            <button
+              type="button"
+              disabled={opsLoading.applyingBatch}
+              onClick={() => applyBatch("approved")}
+            >
+              Approve selected
             </button>
-            <button disabled={opsLoading.applyingBatch} onClick={() => applyBatch("rejected")}>
-              Reject Selected
+            <button
+              type="button"
+              className="secondary"
+              disabled={opsLoading.applyingBatch}
+              onClick={() => applyBatch("rejected")}
+            >
+              Reject selected
             </button>
             <select value={migrateMode} onChange={(e) => setMigrateMode(e.target.value)}>
               <option value="copy">copy</option>
               <option value="move">move</option>
             </select>
-            <button disabled={opsLoading.migrating} onClick={migrateApproved}>
-              {opsLoading.migrating ? "Migrating..." : "Migrate Approved"}
+            <button type="button" disabled={opsLoading.migrating} onClick={migrateApproved}>
+              {opsLoading.migrating ? "Migrating…" : "Migrate approved"}
             </button>
           </div>
 
@@ -554,13 +901,13 @@ function App() {
               <tr>
                 <th>Select</th>
                 <th>Image</th>
-                <th>Primary (Selected)</th>
-                <th>Score</th>
-                <th>Secondary (Selected)</th>
+                <th>Primary</th>
+                <th>Secondary</th>
+                <th>Global top</th>
                 <th>Status</th>
-                <th>Final Tag</th>
-                <th>Debug Scores</th>
-                <th>Review</th>
+                <th>Final tag</th>
+                <th>Debug</th>
+                <th>Actions</th>
               </tr>
             </thead>
             <tbody>
@@ -596,14 +943,42 @@ function App() {
                         />
                       ) : null}
                       <div className="image-path">{item.relative_path || item.file_path || "-"}</div>
+                      {item.review_reason && (
+                        <div className="help">{item.review_reason}</div>
+                      )}
+                    </div>
+                  </td>
+                  <td>
+                    {item.primary_tag ? (
+                      <>
+                        {item.primary_tag}
+                        <div className="muted">
+                          {item.primary_score != null
+                            ? Number(item.primary_score).toFixed(3)
+                            : ""}
+                        </div>
+                      </>
+                    ) : (
+                      <span className="primary-empty">needs review</span>
+                    )}
+                  </td>
+                  <td>
+                    <div className="tag-list">
+                      {(item.secondary_suggestions || []).length === 0
+                        ? "-"
+                        : (item.secondary_suggestions || []).map((s) => (
+                            <span key={`${item.id}-${s.tag}`}>{formatTagScore(s)}</span>
+                          ))}
                     </div>
                   </td>
-                  <td>{item.primary_tag || "-"}</td>
-                  <td>{item.primary_score?.toFixed(3) || "-"}</td>
                   <td>
-                    {(item.secondary_suggestions || [])
-                      .map((s) => `${s.tag} (${Number(s.score).toFixed(3)})`)
-                      .join(", ") || "-"}
+                    <div className="tag-list">
+                      {(item.global_top_tags || []).length === 0
+                        ? "-"
+                        : (item.global_top_tags || []).slice(0, 5).map((s) => (
+                            <span key={`${item.id}-g-${s.tag}`}>{formatTagScore(s)}</span>
+                          ))}
+                    </div>
                   </td>
                   <td>{item.status}</td>
                   <td>
@@ -613,7 +988,7 @@ function App() {
                     />
                   </td>
                   <td>
-                    <button onClick={() => toggleScoreDebug(item.id)}>
+                    <button type="button" className="secondary" onClick={() => toggleScoreDebug(item.id)}>
                       {expandedScoreRows[item.id] ? "Hide JSON" : "Show JSON"}
                     </button>
                     {expandedScoreRows[item.id] && (
@@ -625,30 +1000,37 @@ function App() {
                     )}
                   </td>
                   <td>
-                    <button
-                      disabled={opsLoading.updatingStatus}
-                      onClick={() => updateStatus(item.id, "approved")}
-                    >
-                      Approve
-                    </button>
-                    <button
-                      disabled={opsLoading.updatingStatus}
-                      onClick={() => updateStatus(item.id, "rejected")}
-                    >
-                      Reject
-                    </button>
-                    <button
-                      disabled={opsLoading.updatingStatus}
-                      onClick={() => updateStatus(item.id, "reviewed")}
-                    >
-                      Reviewed
-                    </button>
+                    <div className="actions">
+                      <button
+                        type="button"
+                        disabled={opsLoading.updatingStatus}
+                        onClick={() => updateStatus(item.id, "approved")}
+                      >
+                        Approve
+                      </button>
+                      <button
+                        type="button"
+                        className="secondary"
+                        disabled={opsLoading.updatingStatus}
+                        onClick={() => updateStatus(item.id, "rejected")}
+                      >
+                        Reject
+                      </button>
+                      <button
+                        type="button"
+                        className="secondary"
+                        disabled={opsLoading.updatingStatus}
+                        onClick={() => updateStatus(item.id, "reviewed")}
+                      >
+                        Reviewed
+                      </button>
+                    </div>
                   </td>
                 </tr>
               ))}
             </tbody>
           </table>
-          {runMeta && <pre>{JSON.stringify(runMeta.counts, null, 2)}</pre>}
+          {runMeta && <pre className="debug-json">{JSON.stringify(runMeta.counts, null, 2)}</pre>}
         </section>
       )}
     </div>

frontend/src/api.js

@@ -8,6 +8,12 @@ const defaultSettings = {
   default_migrate_mode: "copy",
   scan_recursive: true,
   experimental_media_enabled: false,
+  selected_tags: [],
+  max_inference_workers: 2,
+  inference_batch_size: 1,
+  force_cpu_inference: false,
+  tagger_model: "wd_swinv2_v3",
+  wd_general_threshold: 0.35,
 };
 const mockTags = [
   "1girl",
@@ -136,6 +142,9 @@ function makeMockItems(runId, selectedFolders, threshold) {
         .filter((x) => x !== tag)
         .slice(0, 3)
         .map((x, i) => ({ tag: x, score: Math.max(0.2, score - 0.1 - i * 0.05) })),
+      global_top_tags: [tag, ...pool.filter((x) => x !== tag)]
+        .slice(0, 5)
+        .map((x, i) => ({ tag: x, score: Math.max(0.15, score - i * 0.07) })),
       suggested_destination: `${mockState.settings.categories_root || "/mock/categories"}/${tag}`,
       final_tag: tag,
       final_destination: `${mockState.settings.categories_root || "/mock/categories"}/${tag}`,
@@ -173,6 +182,7 @@ function computeMockStatus(run) {
     batch_size: 1,
     avg_infer_ms_per_image: null,
     queue_seed: null,
+    tagger_model: run.tagger_model || mockState.settings.tagger_model || "wd_swinv2_v3",
   };
 }
 
@@ -190,9 +200,29 @@ function mockRequest(path, options = {}) {
       cpu_available: true,
       forced_cpu: false,
       likely_device: "cpu",
+      cuda_usable: false,
+      tagger_model: mockState.settings.tagger_model || "wd_swinv2_v3",
       mock_mode: true,
     });
   }
+  if (path === "/scan/preview" && method === "GET") {
+    return Promise.resolve({
+      root_repo: mockState.settings.root_repo || "/mock/images",
+      recursive: Boolean(mockState.settings.scan_recursive),
+      experimental_media_enabled: Boolean(mockState.settings.experimental_media_enabled),
+      excluded_dirs: mockState.settings.categories_root
+        ? [mockState.settings.categories_root]
+        : [],
+      stats: {
+        total_files: 12,
+        eligible_images: 8,
+        ignored_unsupported: 3,
+        ignored_gif: 1,
+        failed_to_read: 0,
+      },
+      sample_paths: ["/mock/images/sample_1.jpg"],
+    });
+  }
   if (path.startsWith("/tags") && method === "GET") {
     const queryString = path.includes("?") ? path.split("?")[1] : "";
     const params = new URLSearchParams(queryString);
@@ -223,6 +253,7 @@ function mockRequest(path, options = {}) {
       root_repo: mockState.settings.root_repo,
       categories_root: mockState.settings.categories_root,
       confidence_threshold: threshold,
+      tagger_model: mockState.settings.tagger_model || "wd_swinv2_v3",
       status: "pending",
       total_images: items.length,
       processed_images: 0,
@@ -374,12 +405,12 @@ export const api = {
   },
   getSettings: () => request("/settings"),
   getProviders: () => request("/providers"),
+  previewScan: () => request("/scan/preview"),
   saveSettings: (payload) =>
     request("/settings", {
       method: "PUT",
       body: JSON.stringify(payload),
-    }),
-  startRun: (payload) =>
+    }),  startRun: (payload) =>
     request("/runs/start", {
       method: "POST",
       body: JSON.stringify(payload),

frontend/src/styles.css

@@ -1,22 +1,124 @@
+:root {
+  --bg: #eef1f6;
+  --bg-accent: #e4ebf5;
+  --surface: #fbfcfe;
+  --surface-2: #f3f6fb;
+  --ink: #1a2332;
+  --muted: #5b667a;
+  --line: #d5dde9;
+  --accent: #245bdb;
+  --accent-soft: #dce7ff;
+  --warn: #8a5a00;
+  --warn-bg: #fff6e4;
+  --danger: #9b2c2c;
+  --danger-bg: #ffe8e8;
+  --ok: #166534;
+  --radius: 10px;
+  --shadow: 0 1px 2px rgba(26, 35, 50, 0.06);
+  --font-ui: "Figtree", "Segoe UI", sans-serif;
+  --font-display: "Fraunces", Georgia, serif;
+}
+
+* {
+  box-sizing: border-box;
+}
+
 body {
   margin: 0;
-  font-family: Inter, Arial, sans-serif;
-  background: #f4f6fb;
-  color: #1d2433;
+  font-family: var(--font-ui);
+  background:
+    radial-gradient(1200px 500px at 10% -10%, #d9e6ff 0%, transparent 55%),
+    radial-gradient(900px 400px at 100% 0%, #e8f0ea 0%, transparent 50%),
+    var(--bg);
+  color: var(--ink);
+  min-height: 100vh;
 }
 
 .container {
-  max-width: 1200px;
+  max-width: 1180px;
   margin: 0 auto;
-  padding: 24px;
+  padding: 28px 20px 96px;
+}
+
+.app-header {
+  margin-bottom: 22px;
+}
+
+.app-header h1 {
+  margin: 0 0 6px;
+  font-family: var(--font-display);
+  font-size: clamp(1.8rem, 3vw, 2.4rem);
+  font-weight: 700;
+  letter-spacing: -0.02em;
+}
+
+.lede {
+  margin: 0 0 14px;
+  color: var(--muted);
+  max-width: 62ch;
+  line-height: 1.45;
+}
+
+.provider-strip {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px 14px;
+  padding: 10px 12px;
+  background: var(--surface);
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  box-shadow: var(--shadow);
+  font-size: 13px;
+}
+
+.provider-strip span {
+  color: var(--muted);
 }
 
-.card {
-  background: #ffffff;
-  border-radius: 12px;
-  padding: 16px;
+.provider-strip strong {
+  color: var(--ink);
+  font-weight: 600;
+}
+
+.panel {
+  background: var(--surface);
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  padding: 18px 18px 14px;
   margin-bottom: 16px;
-  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.08);
+  box-shadow: var(--shadow);
+}
+
+.panel h2 {
+  margin: 0 0 4px;
+  font-family: var(--font-display);
+  font-size: 1.35rem;
+  font-weight: 600;
+}
+
+.kicker {
+  display: block;
+  margin-bottom: 12px;
+  color: var(--muted);
+  font-size: 13px;
+  line-height: 1.4;
+}
+
+.settings-section {
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  padding: 12px 14px 14px;
+  margin: 0 0 12px;
+  background: var(--surface-2);
+}
+
+.settings-section > legend {
+  padding: 0 6px;
+  font-size: 12px;
+  font-weight: 700;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  color: var(--muted);
 }
 
 .grid {
@@ -25,38 +127,235 @@ body {
   gap: 12px;
 }
 
+.grid-1 {
+  grid-template-columns: 1fr;
+}
+
 label {
   display: flex;
   flex-direction: column;
   gap: 6px;
   font-size: 14px;
+  font-weight: 500;
+}
+
+.inline-check {
+  flex-direction: row;
+  align-items: center;
+  gap: 0.5rem;
+  font-weight: 500;
+}
+
+.help {
+  margin: 4px 0 0;
+  color: var(--muted);
+  font-size: 12px;
+  font-weight: 400;
+  line-height: 1.35;
+}
+
+.model-options {
+  display: grid;
+  gap: 8px;
+}
+
+.model-option {
+  display: flex;
+  gap: 10px;
+  align-items: flex-start;
+  padding: 10px 12px;
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  background: var(--surface);
+  cursor: pointer;
+}
+
+.model-option:has(input:checked) {
+  border-color: #9bb6f0;
+  background: var(--accent-soft);
+}
+
+.model-option input {
+  margin-top: 3px;
+}
+
+.model-option strong {
+  display: block;
+  font-size: 14px;
+}
+
+.model-option span {
+  display: block;
+  color: var(--muted);
+  font-size: 12px;
+  font-weight: 400;
+  margin-top: 2px;
 }
 
 input,
 select,
-button {
-  padding: 8px;
-  border: 1px solid #ccd1dc;
+button,
+textarea {
+  padding: 8px 10px;
+  border: 1px solid var(--line);
   border-radius: 8px;
+  font: inherit;
+  color: var(--ink);
+  background: #fff;
 }
 
 button {
   cursor: pointer;
-  background: #1d4ed8;
+  background: var(--accent);
   border: none;
   color: #fff;
+  font-weight: 600;
+}
+
+button:disabled {
+  opacity: 0.55;
+  cursor: not-allowed;
+}
+
+button.secondary {
+  background: #e8edf7;
+  color: var(--ink);
+}
+
+button.danger {
+  background: #b42318;
+}
+
+.sticky-save {
+  position: sticky;
+  bottom: 12px;
+  z-index: 20;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  margin-top: 14px;
+  padding: 10px 12px;
+  border: 1px solid #b8c9f0;
+  border-radius: 10px;
+  background: rgba(251, 252, 254, 0.96);
+  backdrop-filter: blur(6px);
+  box-shadow: 0 8px 24px rgba(26, 35, 50, 0.12);
+}
+
+.sticky-save .dirty {
+  color: var(--warn);
+  font-size: 13px;
+  font-weight: 600;
+}
+
+.sticky-save .clean {
+  color: var(--muted);
+  font-size: 13px;
 }
 
 .stats {
   display: flex;
-  gap: 16px;
+  flex-wrap: wrap;
+  gap: 10px 16px;
   margin: 10px 0;
+  font-size: 13px;
+}
+
+.metric {
+  min-width: 88px;
+}
+
+.metric .label {
+  display: block;
+  color: var(--muted);
+  font-size: 11px;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+
+.metric .value {
+  font-weight: 700;
+  font-size: 1.05rem;
 }
 
 .actions {
   display: flex;
+  flex-wrap: wrap;
   gap: 10px;
   margin: 10px 0;
+  align-items: center;
+}
+
+.progress-track {
+  width: 100%;
+  height: 5px;
+  background: #dde4f0;
+  border-radius: 999px;
+  overflow: hidden;
+  margin: 8px 0 12px;
+}
+
+.progress-fill {
+  height: 100%;
+  background: linear-gradient(90deg, #2f6cf0, #4aa3ff);
+  border-radius: 999px;
+  transition: width 0.25s ease;
+}
+
+.tag-suggestions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  margin: 8px 0 4px;
+  max-height: 160px;
+  overflow-y: auto;
+}
+
+.tag-suggestion {
+  background: var(--accent-soft);
+  color: #1e3a8a;
+  border: 1px solid #c7d2fe;
+  font-size: 13px;
+  padding: 4px 8px;
+  font-weight: 500;
+}
+
+.tag-suggestion:hover {
+  background: #dbeafe;
+}
+
+.chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 4px 8px;
+  background: #eef2ff;
+  border: 1px solid #c7d2fe;
+  border-radius: 999px;
+  font-size: 13px;
+}
+
+.chip button {
+  padding: 0 6px;
+  border-radius: 999px;
+  background: transparent;
+  color: #334155;
+  font-weight: 700;
+}
+
+.muted {
+  color: var(--muted);
+  font-size: 13px;
+}
+
+.scan-preview {
+  margin-top: 8px;
+  padding: 10px 12px;
+  border-radius: 8px;
+  background: #eef7f0;
+  border: 1px solid #c9e2d1;
+  font-size: 13px;
 }
 
 table {
@@ -67,22 +366,36 @@ table {
 
 th,
 td {
-  border: 1px solid #e4e8ef;
-  padding: 6px;
+  border: 1px solid var(--line);
+  padding: 8px;
   text-align: left;
   vertical-align: top;
 }
 
+th {
+  background: var(--surface-2);
+  font-size: 12px;
+  text-transform: uppercase;
+  letter-spacing: 0.03em;
+  color: var(--muted);
+}
+
 .needs-review {
-  background: #fff8e7;
+  background: var(--warn-bg);
+}
+
+.primary-empty {
+  color: var(--warn);
+  font-weight: 600;
 }
 
 .error {
-  background: #ffe7e7;
+  background: var(--danger-bg);
   border: 1px solid #f5b7b7;
   border-radius: 8px;
   padding: 10px;
   margin-bottom: 12px;
+  color: var(--danger);
 }
 
 .image-cell {
@@ -96,7 +409,7 @@ td {
   width: 140px;
   height: 140px;
   object-fit: contain;
-  border: 1px solid #e4e8ef;
+  border: 1px solid var(--line);
   border-radius: 8px;
   background: #f8faff;
 }
@@ -107,6 +420,13 @@ td {
   overflow-wrap: anywhere;
 }
 
+.tag-list {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  font-size: 12px;
+}
+
 .debug-json {
   margin-top: 6px;
   max-width: 360px;
@@ -114,8 +434,19 @@ td {
   overflow: auto;
   font-size: 11px;
   line-height: 1.35;
-  background: #0f172a;
+  background: #152033;
   color: #e2e8f0;
   border-radius: 8px;
   padding: 8px;
 }
+
+@media (max-width: 760px) {
+  .grid {
+    grid-template-columns: 1fr;
+  }
+
+  .sticky-save {
+    flex-direction: column;
+    align-items: stretch;
+  }
+}