Enhance README and backend API for GPU inference support. Updated README to include GPU visibility verification, runtime controls, and examples for inference settings. Modified backend API to add new endpoints for provider health checks and improved inference handling with batch processing capabilities. Updated database schema to include scan_recursive setting and enhanced telemetry tracking for inference runs. Improved tests to validate new API responses and functionality.

README.md

@@ -105,11 +105,44 @@ 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 and logs provider errors. Ensure CUDA 12.x + cuDNN 9.x compatibility for GPU inference.
+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.
+
+### Verify GPU visibility
+
+```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.
+
+### Runtime controls
+
+- `MAX_INFERENCE_WORKERS` (default `2`, clamped to `1..16`): controls conservative thread-pool parallelism for per-image inference.
+- `FORCE_CPU_INFERENCE=true`: force reported/expected CPU path even if CUDA provider is available.
+- `INFERENCE_MODE=batch|single` (default `batch`): prefer GPU-first batched inference or legacy single-image inference.
+- `INFERENCE_BATCH_SIZE` (default `8`, clamped to `1..64`): request batch size for batched inference. If batch inference fails, runtime auto-falls back by splitting batches down to single-image.
+- `QUEUE_SHUFFLE_ENABLED=true|false` (default `true`): stochastic queue ordering toggle.
+- `QUEUE_SHUFFLE_SEED=<int>` (default `run_id`): deterministic seed for reproducible queue shuffling.
+
+Examples:
+
+```bash
+# CPU-safe baseline
+FORCE_CPU_INFERENCE=true MAX_INFERENCE_WORKERS=1 ../.venv/bin/uvicorn app.main:app --host 127.0.0.1 --port 8000 --reload
+
+# Throughput mode (tune workers to your CPU/GPU memory limits)
+MAX_INFERENCE_WORKERS=4 ../.venv/bin/uvicorn app.main:app --host 127.0.0.1 --port 8000 --reload
+
+# GPU-first batching + seeded stochastic queue
+INFERENCE_MODE=batch INFERENCE_BATCH_SIZE=8 QUEUE_SHUFFLE_ENABLED=true QUEUE_SHUFFLE_SEED=1337 MAX_INFERENCE_WORKERS=4 ../.venv/bin/uvicorn app.main:app --host 127.0.0.1 --port 8000 --reload
+```
 
 ## API Surface (High Level)
 
 - `GET /health`
+- `GET /health/providers`
+- `GET /api/providers`
 - `GET/PUT /api/settings`
 - `GET /api/tags`
 - `POST /api/runs/start`

backend/app/api.py

@@ -1,9 +1,14 @@
 from __future__ import annotations
 
+import os
 import logging
+import random
 import threading
+from concurrent.futures import FIRST_COMPLETED, Future, ThreadPoolExecutor, wait
+from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
+import time
 
 from fastapi import APIRouter, HTTPException, Query
 from fastapi.responses import FileResponse
@@ -24,6 +29,7 @@ from .services import (
     choose_best_tags,
     discover_tag_folders,
     extract_scores,
+    extract_scores_batch,
     load_known_tags,
     migrate_file,
     resolve_settings,
@@ -42,12 +48,188 @@ SUPPORTED_PREVIEW_SUFFIXES = {
     ".webp": "image/webp",
     ".bmp": "image/bmp",
 }
+_RUN_TELEMETRY: dict[int, dict[str, object]] = {}
+_RUN_TELEMETRY_LOCK = threading.Lock()
+
+
+@dataclass
+class _ImageInferenceResult:
+    image_path: Path
+    scores: dict[str, float]
+    primary_tag: str | None
+    primary_score: float | None
+    secondary: list[dict[str, float]]
+    needs_review: bool
+    reason: str | None
+    inference_failed: bool
 
 
 def _now_iso() -> str:
     return datetime.now(timezone.utc).isoformat()
 
 
+def _get_max_inference_workers() -> int:
+    raw = os.getenv("MAX_INFERENCE_WORKERS", "2").strip()
+    try:
+        value = int(raw)
+    except ValueError:
+        value = 2
+    return max(1, min(value, 16))
+
+
+def _get_inference_mode() -> str:
+    raw = os.getenv("INFERENCE_MODE", "batch").strip().lower()
+    return "single" if raw == "single" else "batch"
+
+
+def _get_inference_batch_size() -> int:
+    raw = os.getenv("INFERENCE_BATCH_SIZE", "8").strip()
+    try:
+        value = int(raw)
+    except ValueError:
+        value = 8
+    return max(1, min(value, 64))
+
+
+def _get_queue_shuffle_enabled() -> bool:
+    raw = os.getenv("QUEUE_SHUFFLE_ENABLED", "true").strip().lower()
+    return raw not in {"0", "false", "no", "off"}
+
+
+def _get_queue_shuffle_seed(run_id: int) -> int:
+    raw = os.getenv("QUEUE_SHUFFLE_SEED", "").strip()
+    if raw:
+        try:
+            return int(raw)
+        except ValueError:
+            pass
+    return int(run_id)
+
+
+def _set_run_telemetry(run_id: int, **kwargs) -> None:
+    with _RUN_TELEMETRY_LOCK:
+        telemetry = _RUN_TELEMETRY.get(run_id, {})
+        telemetry.update(kwargs)
+        _RUN_TELEMETRY[run_id] = telemetry
+
+
+def _get_run_telemetry(run_id: int) -> dict[str, object]:
+    with _RUN_TELEMETRY_LOCK:
+        return dict(_RUN_TELEMETRY.get(run_id, {}))
+
+
+def _is_provider_related_error(err: Exception) -> bool:
+    msg = str(err).lower()
+    keywords = ("cuda", "cudnn", "executionprovider", "provider", "onnxruntime", "gpu")
+    return any(k in msg for k in keywords)
+
+
+def _infer_one_image(
+    image_path: Path, matched_tags: set[str], confidence_threshold: float
+) -> _ImageInferenceResult:
+    try:
+        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,
+        )
+    except Exception as err:
+        if _is_provider_related_error(err):
+            logger.exception("inference_provider_failure image=%s", image_path)
+        else:
+            logger.exception("inference_failed image=%s", image_path)
+        return _ImageInferenceResult(
+            image_path=image_path,
+            scores={},
+            primary_tag=None,
+            primary_score=None,
+            secondary=[],
+            needs_review=True,
+            reason="Inference failed for this image; requires manual review.",
+            inference_failed=True,
+        )
+
+
+def _infer_batch_with_fallback(
+    image_paths: list[Path],
+    matched_tags: set[str],
+    confidence_threshold: float,
+    requested_mode: str,
+) -> tuple[list[_ImageInferenceResult], float, str]:
+    if not image_paths:
+        return [], 0.0, "none"
+
+    if requested_mode != "batch" or len(image_paths) == 1:
+        start = time.perf_counter()
+        rows = [_infer_one_image(image_paths[0], matched_tags, confidence_threshold)]
+        elapsed_ms = (time.perf_counter() - start) * 1000.0
+        mode = "single" if requested_mode == "single" else "single_fallback"
+        return rows, elapsed_ms, mode
+
+    start = time.perf_counter()
+    try:
+        scores_by_image = extract_scores_batch(image_paths)
+        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,
+                )
+            )
+        elapsed_ms = (time.perf_counter() - start) * 1000.0
+        return rows, elapsed_ms, "batch"
+    except Exception as err:
+        if _is_provider_related_error(err):
+            logger.exception("batch_inference_provider_failure batch_size=%d", len(image_paths))
+        else:
+            logger.exception("batch_inference_failed batch_size=%d", len(image_paths))
+        if len(image_paths) > 1:
+            mid = len(image_paths) // 2
+            left_rows, left_ms, _ = _infer_batch_with_fallback(
+                image_paths[:mid], matched_tags, confidence_threshold, "batch"
+            )
+            right_rows, right_ms, _ = _infer_batch_with_fallback(
+                image_paths[mid:], matched_tags, confidence_threshold, "batch"
+            )
+            return left_rows + right_rows, left_ms + right_ms, "batch_fallback"
+        row = _infer_one_image(image_paths[0], matched_tags, confidence_threshold)
+        elapsed_ms = (time.perf_counter() - start) * 1000.0
+        return [row], elapsed_ms, "single_fallback"
+
+
 def _settings_from_db() -> AppSettings:
     row = fetch_one("SELECT * FROM settings WHERE id = 1")
     if not row:
@@ -57,6 +239,7 @@ def _settings_from_db() -> AppSettings:
         categories_root=row["categories_root"],
         confidence_threshold=float(row["confidence_threshold"]),
         default_migrate_mode=row["default_migrate_mode"],
+        scan_recursive=bool(row.get("scan_recursive", 1)),
     )
 
 
@@ -90,6 +273,7 @@ def _run_status_from_row(row: dict) -> RunStatusResponse:
     pct = 0.0 if total <= 0 else min(100.0, (processed / total) * 100.0)
     item_count_row = fetch_one("SELECT COUNT(*) AS cnt FROM items WHERE run_id = ?", (row["id"],))
     has_items = bool(item_count_row and int(item_count_row["cnt"]) > 0)
+    telemetry = _get_run_telemetry(row["id"])
     return RunStatusResponse(
         run_id=row["id"],
         status=row.get("status") or "pending",
@@ -102,6 +286,10 @@ def _run_status_from_row(row: dict) -> RunStatusResponse:
         last_error=row.get("last_error"),
         cancel_requested=bool(row.get("cancel_requested") or 0),
         has_items=has_items,
+        inference_mode=telemetry.get("inference_mode"),
+        batch_size=telemetry.get("batch_size"),
+        avg_infer_ms_per_image=telemetry.get("avg_infer_ms_per_image"),
+        queue_seed=telemetry.get("queue_seed"),
     )
 
 
@@ -123,80 +311,175 @@ def _execute_run(
     categories_root: Path,
     confidence_threshold: float,
     matched_tags: set[str],
+    scan_recursive: bool = True,
 ) -> None:
     try:
         execute(
             "UPDATE runs SET status = 'running', started_at = ?, last_error = NULL WHERE id = ?",
             (_now_iso(), run_id),
         )
-        scan_output = scan_images(root_repo)
+        scan_output = scan_images(root_repo, exclude_dirs={categories_root}, recursive=scan_recursive)
         execute("UPDATE runs SET total_images = ? WHERE id = ?", (scan_output.stats.eligible_images, run_id))
+        logger.info(
+            "run_scan_complete run_id=%d total_files=%d eligible=%d "
+            "ignored_gif=%d ignored_unsupported=%d failed_to_read=%d",
+            run_id,
+            scan_output.stats.total_files,
+            scan_output.stats.eligible_images,
+            scan_output.stats.ignored_gif,
+            scan_output.stats.ignored_unsupported,
+            scan_output.stats.failed_to_read,
+        )
+
+        queue_shuffle_enabled = _get_queue_shuffle_enabled()
+        queue_seed = _get_queue_shuffle_seed(run_id)
+        ordered_paths = list(scan_output.image_paths)
+        if queue_shuffle_enabled:
+            rng = random.Random(queue_seed)
+            rng.shuffle(ordered_paths)
+        inference_mode = _get_inference_mode()
+        configured_batch_size = _get_inference_batch_size()
+        batch_size = 1 if inference_mode == "single" else configured_batch_size
+        _set_run_telemetry(
+            run_id,
+            queue_seed=queue_seed,
+            inference_mode=inference_mode,
+            batch_size=batch_size,
+            avg_infer_ms_per_image=0.0,
+        )
+        logger.info(
+            "run_queue_config run_id=%d shuffle=%s seed=%d mode=%s batch_size=%d",
+            run_id,
+            queue_shuffle_enabled,
+            queue_seed,
+            inference_mode,
+            batch_size,
+        )
 
         processed = 0
         failed = 0
-        for image_path in scan_output.image_paths:
-            if _is_cancel_requested(run_id):
-                execute(
-                    "UPDATE runs SET status = 'cancelled', finished_at = ? WHERE id = ?",
-                    (_now_iso(), run_id),
-                )
-                logger.info("run_cancelled run_id=%d processed=%d", run_id, processed)
-                return
-
-            relative_path = str(image_path.relative_to(root_repo))
-            try:
-                scores = extract_scores(image_path)
-                primary_tag, primary_score, secondary = choose_best_tags(scores, matched_tags)
-                needs_review = False
-                reason = None
-            except Exception:
-                logger.exception("inference_failed run_id=%d image=%s", run_id, image_path)
-                scores, primary_tag, primary_score, secondary = {}, None, None, []
-                needs_review = True
-                reason = "Inference failed for this image; requires manual review."
-                failed += 1
+        cancelled = False
+        infer_elapsed_ms_total = 0.0
+        infer_sample_count = 0
+        max_workers = _get_max_inference_workers()
+        logger.info(
+            "run_inference_workers run_id=%d workers=%d total_images=%d",
+            run_id,
+            max_workers,
+            scan_output.stats.eligible_images,
+        )
 
-            if primary_tag is None and reason is None:
-                needs_review = True
-                reason = "No matching tags found in selected folders."
-            elif (
-                primary_score is not None
-                and primary_score < confidence_threshold
-                and reason is None
-            ):
-                needs_review = True
-                reason = f"Below threshold ({primary_score:.3f} < {confidence_threshold:.3f})."
+        with ThreadPoolExecutor(max_workers=max_workers, thread_name_prefix="infer") as executor:
+            pending: dict[Future[tuple[list[_ImageInferenceResult], float, str]], list[Path]] = {}
+            batches = [
+                ordered_paths[idx : idx + batch_size]
+                for idx in range(0, len(ordered_paths), batch_size)
+            ]
+            iterator = iter(batches)
+
+            def _submit_until_capacity() -> None:
+                while len(pending) < max_workers:
+                    try:
+                        next_batch = next(iterator)
+                    except StopIteration:
+                        return
+                    future = executor.submit(
+                        _infer_batch_with_fallback,
+                        next_batch,
+                        matched_tags,
+                        confidence_threshold,
+                        inference_mode,
+                    )
+                    pending[future] = next_batch
+
+            _submit_until_capacity()
+            while pending:
+                if _is_cancel_requested(run_id):
+                    cancelled = True
+                    for future in pending:
+                        future.cancel()
+                    break
+
+                done, _ = wait(set(pending.keys()), return_when=FIRST_COMPLETED)
+                for future in done:
+                    pending.pop(future)
+                    if future.cancelled():
+                        continue
+                    batch_results, elapsed_ms, used_mode = future.result()
+                    infer_elapsed_ms_total += elapsed_ms
+                    infer_sample_count += len(batch_results)
+                    avg_ms = (
+                        infer_elapsed_ms_total / infer_sample_count if infer_sample_count else 0.0
+                    )
+                    _set_run_telemetry(
+                        run_id,
+                        inference_mode=used_mode if used_mode != "single_fallback" else "single",
+                        batch_size=batch_size,
+                        avg_infer_ms_per_image=avg_ms,
+                    )
 
-            suggested_destination = (
-                str(categories_root / primary_tag) if primary_tag is not None else None
-            )
+                    for result in batch_results:
+                        relative_path = str(result.image_path.relative_to(root_repo))
+                        suggested_destination = (
+                            str(categories_root / result.primary_tag)
+                            if result.primary_tag is not None
+                            else None
+                        )
+                        execute(
+                            """
+                            INSERT INTO items (
+                                run_id, file_path, relative_path, primary_tag, primary_score, secondary_json,
+                                full_scores_json, suggested_destination, final_tag, final_destination, status, needs_review, review_reason
+                            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                            """,
+                            (
+                                run_id,
+                                str(result.image_path),
+                                relative_path,
+                                result.primary_tag,
+                                result.primary_score,
+                                to_json(result.secondary),
+                                to_json(result.scores),
+                                suggested_destination,
+                                result.primary_tag,
+                                suggested_destination,
+                                "approved" if not result.needs_review else "proposed",
+                                1 if result.needs_review else 0,
+                                result.reason,
+                            ),
+                        )
+                        processed += 1
+                        if result.inference_failed:
+                            failed += 1
+                        _update_run_progress(run_id, processed, failed)
+                        if processed % 10 == 0:
+                            logger.info(
+                                "run_progress run_id=%d processed=%d total=%d avg_infer_ms=%.2f",
+                                run_id,
+                                processed,
+                                scan_output.stats.eligible_images,
+                                avg_ms,
+                            )
+                _submit_until_capacity()
+
+        if cancelled:
+            # Reset partial run artifacts so cancelled runs do not look like
+            # "missing file" runs with incomplete queues.
+            execute("DELETE FROM items WHERE run_id = ?", (run_id,))
             execute(
                 """
-                INSERT INTO items (
-                    run_id, file_path, relative_path, primary_tag, primary_score, secondary_json,
-                    full_scores_json, suggested_destination, final_tag, final_destination, status, needs_review, review_reason
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                UPDATE runs
+                SET status = 'cancelled',
+                    finished_at = ?,
+                    total_images = 0,
+                    processed_images = 0,
+                    failed_images = 0
+                WHERE id = ?
                 """,
-                (
-                    run_id,
-                    str(image_path),
-                    relative_path,
-                    primary_tag,
-                    primary_score,
-                    to_json(secondary),
-                    to_json(scores),
-                    suggested_destination,
-                    primary_tag,
-                    suggested_destination,
-                    "approved" if not needs_review else "proposed",
-                    1 if needs_review else 0,
-                    reason,
-                ),
+                (_now_iso(), run_id),
             )
-            processed += 1
-            _update_run_progress(run_id, processed, failed)
-            if processed % 10 == 0:
-                logger.info("run_progress run_id=%d processed=%d total=%d", run_id, processed, scan_output.stats.eligible_images)
+            logger.info("run_cancelled run_id=%d processed=%d", run_id, processed)
+            return
 
         execute(
             "UPDATE runs SET status = 'completed', finished_at = ? WHERE id = ?",
@@ -222,7 +505,8 @@ def save_settings(payload: SaveSettingsRequest) -> AppSettings:
         execute(
             """
             UPDATE settings
-            SET root_repo = ?, categories_root = ?, confidence_threshold = ?, default_migrate_mode = ?
+            SET root_repo = ?, categories_root = ?, confidence_threshold = ?,
+                default_migrate_mode = ?, scan_recursive = ?
             WHERE id = 1
             """,
             (
@@ -230,6 +514,7 @@ def save_settings(payload: SaveSettingsRequest) -> AppSettings:
                 payload.categories_root,
                 payload.confidence_threshold,
                 payload.default_migrate_mode,
+                1 if payload.scan_recursive else 0,
             ),
         )
     except Exception:
@@ -246,6 +531,59 @@ def search_tags(query: str = Query("", min_length=0), limit: int = 50) -> dict:
     return {"items": known[:limit], "count": len(known)}
 
 
+@router.get("/scan/preview")
+def scan_preview() -> dict:
+    """Run image discovery on the configured root_repo and return stats without inference."""
+    settings = _settings_from_db()
+    if not settings.root_repo:
+        raise HTTPException(status_code=400, detail="root_repo is not configured in settings")
+    root_repo = Path(settings.root_repo).expanduser()
+    exclude_dirs: set[Path] = set()
+    if settings.categories_root:
+        exclude_dirs.add(Path(settings.categories_root).expanduser())
+    try:
+        output = scan_images(
+            root_repo,
+            exclude_dirs=exclude_dirs or None,
+            recursive=settings.scan_recursive,
+        )
+    except ValueError as err:
+        raise HTTPException(status_code=400, detail=str(err))
+    return {
+        "root_repo": str(root_repo),
+        "recursive": settings.scan_recursive,
+        "excluded_dirs": [str(d) for d in exclude_dirs],
+        "stats": output.stats.model_dump(),
+        "sample_paths": [str(p) for p in output.image_paths[:20]],
+    }
+
+
+@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),
+        }
+
+
 @router.post("/runs/start", response_model=StartRunResponse)
 def start_run(payload: StartRunRequest) -> StartRunResponse:
     logger.info("run_start_requested")
@@ -287,7 +625,8 @@ def start_run(payload: StartRunRequest) -> StartRunResponse:
 
     worker = threading.Thread(
         target=_execute_run,
-        args=(run_id, root_repo, categories_root, resolved.confidence_threshold, matched_tags),
+        args=(run_id, root_repo, categories_root, resolved.confidence_threshold, matched_tags,
+              resolved.scan_recursive),
         daemon=True,
     )
     worker.start()

backend/app/main.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import os
 import time
 
 from fastapi import FastAPI
@@ -29,6 +30,31 @@ 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),
+        }
+
+
 @app.middleware("http")
 async def log_requests(request: Request, call_next):
     start = time.perf_counter()
@@ -57,6 +83,8 @@ async def log_requests(request: Request, call_next):
 @app.on_event("startup")
 def startup() -> None:
     _configure_logging()
+    provider_state = _get_provider_snapshot()
+    logger.info("onnx_provider_state state=%s", provider_state)
     logger.info("initializing database at startup")
     init_db()
     logger.info("startup complete")
@@ -67,4 +95,9 @@ def health() -> dict[str, str]:
     return {"status": "ok"}
 
 
+@app.get("/health/providers")
+def health_providers() -> dict[str, object]:
+    return {"status": "ok", **_get_provider_snapshot()}
+
+
 app.include_router(router)

backend/app/schemas.py

@@ -15,6 +15,7 @@ class AppSettings(BaseModel):
     categories_root: str = ""
     confidence_threshold: float = 0.6
     default_migrate_mode: MigrateMode = "copy"
+    scan_recursive: bool = True
 
 
 class SaveSettingsRequest(AppSettings):
@@ -88,6 +89,10 @@ class RunStatusResponse(BaseModel):
     last_error: str | None = None
     cancel_requested: bool = False
     has_items: bool = False
+    inference_mode: str | None = None
+    batch_size: int | None = None
+    avg_infer_ms_per_image: float | None = None
+    queue_seed: int | None = None
 
 
 class UpdateItemRequest(BaseModel):

backend/app/services.py

@@ -10,7 +10,7 @@ from PIL import Image
 
 from .schemas import AppSettings, FolderMapping, MigrationResult, ScanStats
 
-SUPPORTED_IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".bmp", ".webp", ".tiff"}
+SUPPORTED_IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".jfif", ".png", ".bmp", ".webp", ".tiff"}
 VIDEO_EXTENSIONS = {
     ".mp4",
     ".mov",
@@ -22,6 +22,7 @@ VIDEO_EXTENSIONS = {
     ".m4v",
 }
 logger = logging.getLogger(__name__)
+_BATCH_INFERENCE_SUPPORTED: bool | None = None
 
 
 def normalize_tag_name(value: str) -> str:
@@ -78,19 +79,50 @@ class ScanOutput:
     stats: ScanStats
 
 
-def scan_images(root_repo: Path) -> ScanOutput:
+def scan_images(
+    root_repo: Path,
+    exclude_dirs: set[Path] | None = None,
+    recursive: bool = True,
+) -> ScanOutput:
     if not root_repo.exists() or not root_repo.is_dir():
         raise ValueError(f"root_repo does not exist or is not a directory: {root_repo}")
 
+    # Resolve exclude_dirs to absolute paths so prefix matching is reliable.
+    resolved_excludes: set[Path] = set()
+    if exclude_dirs:
+        for d in exclude_dirs:
+            try:
+                resolved_excludes.add(d.resolve())
+            except OSError:
+                pass
+
     total_files = 0
     eligible: list[Path] = []
     ignored_unsupported = 0
     ignored_gif = 0
     failed_to_read = 0
 
-    for path in root_repo.rglob("*"):
-        if not path.is_file():
+    iterator = root_repo.rglob("*") if recursive else root_repo.iterdir()
+    for path in iterator:
+        try:
+            if not path.is_file():
+                continue
+        except OSError:
+            failed_to_read += 1
             continue
+
+        # Skip any path that lives inside an excluded directory.
+        if resolved_excludes:
+            try:
+                resolved_path = path.resolve()
+                if any(
+                    resolved_path == exc or resolved_path.is_relative_to(exc)
+                    for exc in resolved_excludes
+                ):
+                    continue
+            except OSError:
+                pass
+
         total_files += 1
         ext = path.suffix.lower()
         if ext == ".gif":
@@ -99,17 +131,37 @@ def scan_images(root_repo: Path) -> ScanOutput:
         if ext in VIDEO_EXTENSIONS:
             ignored_unsupported += 1
             continue
-        if ext not in SUPPORTED_IMAGE_EXTENSIONS:
-            ignored_unsupported += 1
+
+        if ext in SUPPORTED_IMAGE_EXTENSIONS:
+            # Known image extension: accept without Pillow verification.
+            # Corrupt or unreadable files are handled gracefully during inference.
+            eligible.append(path)
             continue
 
+        # Unknown or missing extension: try content-based detection.
         try:
             with Image.open(path) as img:
-                img.verify()
+                if not img.format:
+                    raise ValueError("Not a recognizable image format")
             eligible.append(path)
         except Exception:
-            failed_to_read += 1
-
+            if ext == "":
+                failed_to_read += 1
+            else:
+                ignored_unsupported += 1
+
+    logger.info(
+        "scan_complete root=%s recursive=%s total_files=%d eligible=%d "
+        "ignored_gif=%d ignored_unsupported=%d failed_to_read=%d excluded_dirs=%d",
+        root_repo,
+        recursive,
+        total_files,
+        len(eligible),
+        ignored_gif,
+        ignored_unsupported,
+        failed_to_read,
+        len(resolved_excludes),
+    )
     return ScanOutput(
         image_paths=eligible,
         stats=ScanStats(
@@ -147,6 +199,57 @@ def extract_scores(image_path: Path) -> dict[str, float]:
     return scores
 
 
+def extract_scores_batch(image_paths: list[Path]) -> list[dict[str, float]]:
+    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,
+        )
+    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
+
+    # 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 choose_best_tags(
     scores: dict[str, float], allowed_tags: set[str], max_secondary: int = 3
 ) -> tuple[str | None, float | None, list[dict[str, float]]]:
@@ -226,4 +329,5 @@ def resolve_settings(
             confidence_threshold if confidence_threshold is not None else current.confidence_threshold
         ),
         default_migrate_mode=current.default_migrate_mode,
+        scan_recursive=current.scan_recursive,
     )

backend/app/storage.py

@@ -27,7 +27,8 @@ def init_db() -> None:
                 root_repo TEXT NOT NULL DEFAULT '',
                 categories_root TEXT NOT NULL DEFAULT '',
                 confidence_threshold REAL NOT NULL DEFAULT 0.6,
-                default_migrate_mode TEXT NOT NULL DEFAULT 'copy'
+                default_migrate_mode TEXT NOT NULL DEFAULT 'copy',
+                scan_recursive INTEGER NOT NULL DEFAULT 1
             );
 
             INSERT OR IGNORE INTO settings (id) VALUES (1);
@@ -67,6 +68,7 @@ def init_db() -> None:
             );
             """
             )
+            _ensure_settings_columns(conn)
             _ensure_runs_columns(conn)
             _ensure_items_columns(conn)
     except sqlite3.DatabaseError:
@@ -74,6 +76,17 @@ def init_db() -> None:
         raise
 
 
+def _ensure_settings_columns(conn: sqlite3.Connection) -> None:
+    expected_columns = {
+        "scan_recursive": "INTEGER NOT NULL DEFAULT 1",
+    }
+    rows = conn.execute("PRAGMA table_info(settings)").fetchall()
+    existing = {row[1] for row in rows}
+    for name, definition in expected_columns.items():
+        if name not in existing:
+            conn.execute(f"ALTER TABLE settings ADD COLUMN {name} {definition}")
+
+
 def _ensure_runs_columns(conn: sqlite3.Connection) -> None:
     expected_columns = {
         "status": "TEXT NOT NULL DEFAULT 'pending'",

backend/tests/test_api_run_progress.py

@@ -1,4 +1,6 @@
 import time
+import os
+import random
 from pathlib import Path
 
 from fastapi.testclient import TestClient
@@ -9,6 +11,17 @@ from app.services import ScanOutput
 from app.storage import execute
 
 
+def test_providers_endpoint_shape():
+    with TestClient(app) as client:
+        resp = client.get("/api/providers")
+        resp.raise_for_status()
+        payload = resp.json()
+        assert "available_providers" in payload
+        assert "likely_device" in payload
+        assert "cuda_available" in payload
+        assert "forced_cpu" in payload
+
+
 def _wait_for_status(client: TestClient, run_id: int, terminal: set[str], timeout_s: float = 5.0):
     start = time.time()
     last = None
@@ -32,7 +45,7 @@ def test_run_progress_reaches_completed(monkeypatch, tmp_path: Path):
     file_path = root / "a.jpg"
     file_path.write_text("fake", encoding="utf-8")
 
-    def fake_scan_images(_root):
+    def fake_scan_images(_root, **kwargs):
         return ScanOutput(
             image_paths=[file_path],
             stats=ScanStats(
@@ -90,7 +103,7 @@ def test_item_preview_returns_image(monkeypatch, tmp_path: Path):
     file_path = root / "preview.jpg"
     file_path.write_bytes(b"fake-image-bytes")
 
-    def fake_scan_images(_root):
+    def fake_scan_images(_root, **kwargs):
         return ScanOutput(
             image_paths=[file_path],
             stats=ScanStats(
@@ -149,7 +162,7 @@ def test_selected_tag_wins_when_global_top_not_selected(monkeypatch, tmp_path: P
     file_path = root / "s.png"
     file_path.write_text("fake", encoding="utf-8")
 
-    def fake_scan_images(_root):
+    def fake_scan_images(_root, **kwargs):
         return ScanOutput(
             image_paths=[file_path],
             stats=ScanStats(
@@ -217,7 +230,7 @@ def test_item_scores_debug_endpoint(monkeypatch, tmp_path: Path):
     file_path = root / "z.jpg"
     file_path.write_text("fake", encoding="utf-8")
 
-    def fake_scan_images(_root):
+    def fake_scan_images(_root, **kwargs):
         return ScanOutput(
             image_paths=[file_path],
             stats=ScanStats(
@@ -280,7 +293,7 @@ def test_run_cancel_sets_cancelled(monkeypatch, tmp_path: Path):
         p.write_text("fake", encoding="utf-8")
         file_paths.append(p)
 
-    def fake_scan_images(_root):
+    def fake_scan_images(_root, **kwargs):
         return ScanOutput(
             image_paths=file_paths,
             stats=ScanStats(
@@ -326,7 +339,179 @@ def test_run_cancel_sets_cancelled(monkeypatch, tmp_path: Path):
         assert final is not None
         assert final["cancel_requested"] is True
         assert final["status"] in {"cancelled", "completed"}
+        if final["status"] == "cancelled":
+            items_resp = client.get(f"/api/runs/{run_id}/items")
+            items_resp.raise_for_status()
+            assert items_resp.json() == []
+            assert final["processed_images"] == 0
+            assert final["total_images"] == 0
 
     # Keep test environment clean of inserted rows.
     execute("DELETE FROM items WHERE run_id = ?", (run_id,))
     execute("DELETE FROM runs WHERE id = ?", (run_id,))
+
+
+def test_seeded_queue_shuffle_is_deterministic(monkeypatch, tmp_path: Path):
+    root = tmp_path / "root_seed"
+    cats = tmp_path / "cats_seed"
+    root.mkdir()
+    cats.mkdir()
+    (cats / "1girl").mkdir()
+    file_paths = []
+    for idx in range(6):
+        p = root / f"{idx}.jpg"
+        p.write_text("fake", encoding="utf-8")
+        file_paths.append(p)
+
+    observed_order: list[str] = []
+
+    def fake_scan_images(_root, **kwargs):
+        return ScanOutput(
+            image_paths=file_paths,
+            stats=ScanStats(
+                total_files=len(file_paths),
+                eligible_images=len(file_paths),
+                ignored_unsupported=0,
+                ignored_gif=0,
+                failed_to_read=0,
+            ),
+        )
+
+    def record_scores(path: Path):
+        observed_order.append(path.name)
+        return {"1girl": 0.88}
+
+    monkeypatch.setattr("app.api.scan_images", fake_scan_images)
+    monkeypatch.setattr("app.api.extract_scores", record_scores)
+    monkeypatch.setattr("app.api.load_known_tags", lambda _p: {"1girl"})
+    monkeypatch.setattr(
+        "app.api.discover_tag_folders",
+        lambda _root, _tags, _selected: [
+            FolderMapping(
+                folder_name="1girl", normalized_name="1girl", matched_tag="1girl", matched=True
+            )
+        ],
+    )
+
+    prev_shuffle = os.environ.get("QUEUE_SHUFFLE_ENABLED")
+    prev_seed = os.environ.get("QUEUE_SHUFFLE_SEED")
+    prev_workers = os.environ.get("MAX_INFERENCE_WORKERS")
+    prev_mode = os.environ.get("INFERENCE_MODE")
+    os.environ["QUEUE_SHUFFLE_ENABLED"] = "true"
+    os.environ["QUEUE_SHUFFLE_SEED"] = "1337"
+    os.environ["MAX_INFERENCE_WORKERS"] = "1"
+    os.environ["INFERENCE_MODE"] = "single"
+    try:
+        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": ["1girl"],
+                },
+            )
+            start_resp.raise_for_status()
+            run_id = start_resp.json()["run_id"]
+            final = _wait_for_status(client, run_id, {"completed", "failed", "cancelled"}, timeout_s=8.0)
+            assert final is not None
+            assert final["status"] == "completed"
+            expected = [p.name for p in file_paths]
+            random.Random(1337).shuffle(expected)
+            assert observed_order == expected
+            execute("DELETE FROM items WHERE run_id = ?", (run_id,))
+            execute("DELETE FROM runs WHERE id = ?", (run_id,))
+    finally:
+        if prev_shuffle is None:
+            os.environ.pop("QUEUE_SHUFFLE_ENABLED", None)
+        else:
+            os.environ["QUEUE_SHUFFLE_ENABLED"] = prev_shuffle
+        if prev_seed is None:
+            os.environ.pop("QUEUE_SHUFFLE_SEED", None)
+        else:
+            os.environ["QUEUE_SHUFFLE_SEED"] = prev_seed
+        if prev_workers is None:
+            os.environ.pop("MAX_INFERENCE_WORKERS", None)
+        else:
+            os.environ["MAX_INFERENCE_WORKERS"] = prev_workers
+        if prev_mode is None:
+            os.environ.pop("INFERENCE_MODE", None)
+        else:
+            os.environ["INFERENCE_MODE"] = prev_mode
+
+
+def test_batch_mode_falls_back_to_single(monkeypatch, tmp_path: Path):
+    root = tmp_path / "root_batch_fallback"
+    cats = tmp_path / "cats_batch_fallback"
+    root.mkdir()
+    cats.mkdir()
+    (cats / "1girl").mkdir()
+    file_paths = []
+    for idx in range(8):
+        p = root / f"{idx}.jpg"
+        p.write_text("fake", encoding="utf-8")
+        file_paths.append(p)
+
+    def fake_scan_images(_root, **kwargs):
+        return ScanOutput(
+            image_paths=file_paths,
+            stats=ScanStats(
+                total_files=len(file_paths),
+                eligible_images=len(file_paths),
+                ignored_unsupported=0,
+                ignored_gif=0,
+                failed_to_read=0,
+            ),
+        )
+
+    def fail_batch(_paths):
+        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.load_known_tags", lambda _p: {"1girl"})
+    monkeypatch.setattr(
+        "app.api.discover_tag_folders",
+        lambda _root, _tags, _selected: [
+            FolderMapping(
+                folder_name="1girl", normalized_name="1girl", matched_tag="1girl", matched=True
+            )
+        ],
+    )
+
+    prev_mode = os.environ.get("INFERENCE_MODE")
+    prev_batch = os.environ.get("INFERENCE_BATCH_SIZE")
+    os.environ["INFERENCE_MODE"] = "batch"
+    os.environ["INFERENCE_BATCH_SIZE"] = "4"
+    try:
+        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": ["1girl"],
+                },
+            )
+            start_resp.raise_for_status()
+            run_id = start_resp.json()["run_id"]
+            final = _wait_for_status(client, run_id, {"completed", "failed", "cancelled"}, timeout_s=8.0)
+            assert final is not None
+            assert final["status"] == "completed"
+            assert final["failed_images"] == 0
+            assert final["processed_images"] == len(file_paths)
+            assert final["inference_mode"] in {"single", "batch_fallback", "single_fallback"}
+            execute("DELETE FROM items WHERE run_id = ?", (run_id,))
+            execute("DELETE FROM runs WHERE id = ?", (run_id,))
+    finally:
+        if prev_mode is None:
+            os.environ.pop("INFERENCE_MODE", None)
+        else:
+            os.environ["INFERENCE_MODE"] = prev_mode
+        if prev_batch is None:
+            os.environ.pop("INFERENCE_BATCH_SIZE", None)
+        else:
+            os.environ["INFERENCE_BATCH_SIZE"] = prev_batch

backend/tests/test_services.py

@@ -38,14 +38,80 @@ def test_scan_images_filters_types(tmp_path: Path) -> None:
     (tmp_path / "video.mp4").write_text("not-video", encoding="utf-8")
     (tmp_path / "anim.gif").write_text("gif", encoding="utf-8")
     (tmp_path / "doc.txt").write_text("txt", encoding="utf-8")
+    # broken.png has a known image extension so it is accepted at scan time;
+    # corrupt files are caught later during inference (not at discovery).
     (tmp_path / "broken.png").write_text("broken", encoding="utf-8")
 
     result = scan_images(tmp_path)
-    assert len(result.image_paths) == 1
-    assert result.stats.eligible_images == 1
+    names = {p.name for p in result.image_paths}
+    assert "ok.jpg" in names
+    assert "broken.png" in names  # accepted at scan; inference will handle corruption
+    assert result.stats.eligible_images == 2
     assert result.stats.ignored_gif == 1
-    assert result.stats.ignored_unsupported >= 2
-    assert result.stats.failed_to_read == 1
+    assert result.stats.ignored_unsupported >= 1  # doc.txt
+    assert result.stats.failed_to_read == 0  # no OSError-level failures
+
+
+def test_scan_images_includes_extensionless_valid_image(tmp_path: Path) -> None:
+    extless = tmp_path / "no_extension_image"
+    Image.new("RGB", (16, 16), color="purple").save(extless, format="PNG")
+
+    result = scan_images(tmp_path)
+    names = {p.name for p in result.image_paths}
+    assert "no_extension_image" in names
+    assert result.stats.eligible_images == 1
+
+
+def test_scan_images_includes_unknown_extension_if_decodable(tmp_path: Path) -> None:
+    odd_ext = tmp_path / "odd_format.weird"
+    Image.new("RGB", (16, 16), color="yellow").save(odd_ext, format="PNG")
+
+    result = scan_images(tmp_path)
+    names = {p.name for p in result.image_paths}
+    assert "odd_format.weird" in names
+    assert result.stats.eligible_images == 1
+    assert result.stats.ignored_unsupported == 0
+
+
+def test_scan_images_rejects_unknown_extension_when_not_image(tmp_path: Path) -> None:
+    non_image = tmp_path / "not_image.weird"
+    non_image.write_text("plain text", encoding="utf-8")
+
+    result = scan_images(tmp_path)
+    names = {p.name for p in result.image_paths}
+    assert "not_image.weird" not in names
+    assert result.stats.eligible_images == 0
+    assert result.stats.ignored_unsupported == 1
+
+
+def test_scan_images_descends_into_subdirectories(tmp_path: Path) -> None:
+    nested = tmp_path / "nested"
+    nested.mkdir()
+    nested_img = nested / "nested.jpg"
+    Image.new("RGB", (16, 16), color="blue").save(nested_img)
+
+    top_img = tmp_path / "top.jpg"
+    Image.new("RGB", (16, 16), color="green").save(top_img)
+
+    result = scan_images(tmp_path)
+    names = {p.name for p in result.image_paths}
+    assert "top.jpg" in names
+    assert "nested.jpg" in names
+
+
+def test_scan_images_excludes_specified_directory(tmp_path: Path) -> None:
+    included_dir = tmp_path / "included"
+    included_dir.mkdir()
+    Image.new("RGB", (16, 16), color="red").save(included_dir / "in.jpg")
+
+    excluded_dir = tmp_path / "excluded"
+    excluded_dir.mkdir()
+    Image.new("RGB", (16, 16), color="blue").save(excluded_dir / "out.jpg")
+
+    result = scan_images(tmp_path, exclude_dirs={excluded_dir})
+    names = {p.name for p in result.image_paths}
+    assert "in.jpg" in names
+    assert "out.jpg" not in names
 
 
 def test_choose_best_tags_single_primary_and_secondary() -> None:

frontend/src/App.jsx

@@ -6,6 +6,7 @@ const DEFAULT_SETTINGS = {
   categories_root: "",
   confidence_threshold: 0.6,
   default_migrate_mode: "copy",
+  scan_recursive: true,
 };
 const ACTIVE_RUN_STORAGE_KEY = "imageClassifierActiveRunId";
 
@@ -18,6 +19,7 @@ function App() {
   const [items, setItems] = useState([]);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState("");
+  const [providerInfo, setProviderInfo] = useState(null);
   const [migrateMode, setMigrateMode] = useState("copy");
   const [selectedIds, setSelectedIds] = useState([]);
   const [tagQuery, setTagQuery] = useState("");
@@ -65,6 +67,9 @@ function App() {
     if (storedRunId > 0) {
       setRunId(storedRunId);
     }
+    api.getProviders()
+      .then((info) => setProviderInfo(info))
+      .catch(() => setProviderInfo(null));
   }, []);
 
   useEffect(() => {
@@ -353,6 +358,13 @@ function App() {
           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>
+      )}
 
       {error && <div className="error">{error}</div>}
 
@@ -396,6 +408,14 @@ function App() {
               <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>
           <button disabled={loading || opsLoading.saving}>Save Settings</button>
         </form>
       </section>
@@ -477,6 +497,17 @@ function App() {
                 {Number(runStatus.progress_pct || 0).toFixed(1)}%)
               </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>
           )}

frontend/src/api.js

@@ -6,6 +6,7 @@ const defaultSettings = {
   categories_root: "",
   confidence_threshold: 0.6,
   default_migrate_mode: "copy",
+  scan_recursive: true,
 };
 const mockTags = [
   "1girl",
@@ -167,6 +168,10 @@ function computeMockStatus(run) {
     last_error: run.last_error || null,
     cancel_requested: Boolean(run.cancel_requested),
     has_items: (run.items || []).length > 0,
+    inference_mode: "single",
+    batch_size: 1,
+    avg_infer_ms_per_image: null,
+    queue_seed: null,
   };
 }
 
@@ -177,6 +182,16 @@ function mockRequest(path, options = {}) {
   if (path === "/settings" && method === "GET") {
     return Promise.resolve(mockState.settings);
   }
+  if (path === "/providers" && method === "GET") {
+    return Promise.resolve({
+      available_providers: ["CPUExecutionProvider"],
+      cuda_available: false,
+      cpu_available: true,
+      forced_cpu: false,
+      likely_device: "cpu",
+      mock_mode: true,
+    });
+  }
   if (path.startsWith("/tags") && method === "GET") {
     const queryString = path.includes("?") ? path.split("?")[1] : "";
     const params = new URLSearchParams(queryString);
@@ -357,6 +372,7 @@ export const api = {
     return request(`/tags?${params.toString()}`);
   },
   getSettings: () => request("/settings"),
+  getProviders: () => request("/providers"),
   saveSettings: (payload) =>
     request("/settings", {
       method: "PUT",