Implement destination folder validation in migrate_run function. Add checks to ensure the destination folder exists and is a directory, with appropriate error handling and logging for failed migrations. This enhances the robustness of the migration process by preventing invalid paths from causing issues.

backend/app/api.py

@@ -1060,6 +1060,30 @@ def migrate_run(run_id: int, payload: MigrateRequest) -> MigrateResponse:
         try:
             if payload.create_missing_folders:
                 destination_folder.mkdir(parents=True, exist_ok=True)
+            elif not destination_folder.exists():
+                failed_count += 1
+                results.append(
+                    {
+                        "item_id": row["id"],
+                        "source": str(source),
+                        "destination": str(destination_folder),
+                        "success": False,
+                        "error": "Destination folder does not exist",
+                    }
+                )
+                continue
+            elif not destination_folder.is_dir():
+                failed_count += 1
+                results.append(
+                    {
+                        "item_id": row["id"],
+                        "source": str(source),
+                        "destination": str(destination_folder),
+                        "success": False,
+                        "error": "Destination path exists but is not a folder",
+                    }
+                )
+                continue
         except Exception:
             failed_count += 1
             results.append(

backend/scripts/audit_classify_accuracy.py

@@ -0,0 +1,151 @@
+"""
+Offline + optional live audit of taxonomy routing and tagger outputs.
+
+Usage (from backend/):
+  ../.venv/Scripts/python.exe scripts/audit_classify_accuracy.py
+  ../.venv/Scripts/python.exe scripts/audit_classify_accuracy.py --images DIR
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import time
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from app.taxonomy import choose_best_destination, reload_taxonomy  # noqa: E402
+
+SELECTED = {
+    "fertilization",
+    "NTR",
+    "incest",
+    "nakadashi",
+    "fellatio",
+    "loli",
+    "shota",
+    "monster_girl",
+    "furry",
+    "Pokemon",
+}
+
+FIXTURES: list[tuple[str, dict[str, float], str | None]] = [
+    ("loli_hard", {"loli": 0.92, "flat_chest": 0.99}, "loli"),
+    ("fashion_fp", {"lolita_fashion": 0.99, "gothic_lolita": 0.95}, None),
+    ("shota_hard", {"shota": 0.88, "1boy": 0.99}, "shota"),
+    ("ntr_hard", {"netorare": 0.8}, "NTR"),
+    ("incest_hard", {"incest": 0.8, "siblings": 0.99}, "incest"),
+    ("siblings_fp", {"siblings": 0.99}, None),
+    ("nakadashi", {"internal_cumshot": 0.9}, "nakadashi"),
+    ("fert_over_creampie", {"fertilization": 0.8, "cum_in_pussy": 0.99}, "fertilization"),
+    ("fellatio_impl", {"deepthroat": 0.9}, "fellatio"),
+    ("monster_girl", {"monster_girl": 0.9, "horns": 0.99}, "monster_girl"),
+    ("parts_fp", {"horns": 0.99, "wings": 0.98}, None),
+    ("furry", {"furry_female": 0.9, "animal_ears": 0.99}, "furry"),
+    ("pokemon", {"pokemon_(creature)": 0.9}, "Pokemon"),
+]
+
+
+def audit_fixtures() -> int:
+    reload_taxonomy()
+    failed = 0
+    print("=== TAXONOMY FIXTURE AUDIT ===")
+    for name, scores, expected in FIXTURES:
+        folder, score, _ = choose_best_destination(scores, SELECTED)
+        ok = folder == expected
+        mark = "PASS" if ok else "FAIL"
+        if not ok:
+            failed += 1
+        print(f"{mark} {name}: got={folder}({score}) expected={expected}")
+    return failed
+
+
+def audit_images(image_dir: Path, models: list[str], limit: int) -> int:
+    from app.services import extract_scores
+
+    paths = sorted(
+        p
+        for p in image_dir.rglob("*")
+        if p.suffix.lower() in {".jpg", ".jpeg", ".png", ".webp", ".bmp"}
+    )[:limit]
+    if not paths:
+        print(f"ERROR: no images under {image_dir}", file=sys.stderr)
+        return 1
+
+    print(f"\n=== MODEL IMAGE AUDIT ({len(paths)} images) ===")
+    failed = 0
+    for model in models:
+        empty = 0
+        routed = 0
+        errors = 0
+        latencies: list[float] = []
+        samples: list[dict] = []
+        for path in paths:
+            t0 = time.perf_counter()
+            try:
+                scores = extract_scores(path, tagger_model=model, wd_general_threshold=0.35)
+            except Exception as err:
+                errors += 1
+                print(f"  ERR {model} {path.name}: {err}")
+                continue
+            latencies.append((time.perf_counter() - t0) * 1000)
+            if not scores:
+                empty += 1
+            folder, score, _ = choose_best_destination(scores, SELECTED)
+            if folder is not None:
+                routed += 1
+            if len(samples) < 3:
+                top = sorted(scores.items(), key=lambda kv: kv[1], reverse=True)[:5]
+                samples.append(
+                    {
+                        "file": path.name,
+                        "folder": folder,
+                        "folder_score": score,
+                        "top": [f"{t}={s:.3f}" for t, s in top],
+                    }
+                )
+        avg = sum(latencies) / len(latencies) if latencies else None
+        ok = errors == 0 and empty == 0
+        if not ok:
+            failed += 1
+        print(
+            json.dumps(
+                {
+                    "model": model,
+                    "ok": ok,
+                    "images": len(paths),
+                    "empty_scores": empty,
+                    "errors": errors,
+                    "taxonomy_routed": routed,
+                    "avg_ms": round(avg, 1) if avg is not None else None,
+                    "samples": samples,
+                },
+                indent=2,
+            )
+        )
+    return failed
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--images", type=Path, default=None)
+    parser.add_argument("--limit", type=int, default=12)
+    parser.add_argument(
+        "--models",
+        nargs="+",
+        default=["ml_danbooru", "wd_swinv2_v3", "wd_eva02_large"],
+    )
+    args = parser.parse_args()
+    failed = audit_fixtures()
+    if args.images:
+        failed += audit_images(args.images, args.models, args.limit)
+    else:
+        print("\n(skip image audit: pass --images DIR for live tagger accuracy smoke)")
+    print(f"\n=== DONE failed={failed} ===")
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

backend/tests/test_api_migrate.py

@@ -0,0 +1,378 @@
+"""Post-approval migrate path: API + filesystem behavior."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi.testclient import TestClient
+
+from app.main import app
+from app.storage import execute, fetch_one, to_json
+
+
+def _seed_completed_run(
+    root: Path,
+    cats: Path,
+    items: list[dict],
+    *,
+    status: str = "completed",
+) -> int:
+    run_id = execute(
+        """
+        INSERT INTO runs (
+            root_repo, categories_root, confidence_threshold, status,
+            total_images, processed_images, failed_images, cancel_requested, tagger_model
+        ) VALUES (?, ?, 0.6, ?, ?, ?, 0, 0, 'wd_swinv2_v3')
+        """,
+        (str(root), str(cats), status, len(items), len(items)),
+    )
+    for item in items:
+        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,
+                item["file_path"],
+                item.get("relative_path") or Path(item["file_path"]).name,
+                item.get("primary_tag"),
+                item.get("primary_score"),
+                to_json(item.get("secondary") or []),
+                to_json(item.get("scores") or {}),
+                item.get("suggested_destination"),
+                item.get("final_tag", item.get("primary_tag")),
+                item.get("final_destination"),
+                item.get("status", "approved"),
+                1 if item.get("needs_review") else 0,
+                item.get("review_reason"),
+            ),
+        )
+    return run_id
+
+
+def test_migrate_copy_approved_only_and_skips_non_approved(tmp_path: Path) -> None:
+    root = tmp_path / "root"
+    cats = tmp_path / "cats"
+    root.mkdir()
+    cats.mkdir()
+    a = root / "a.jpg"
+    b = root / "b.jpg"
+    c = root / "c.jpg"
+    a.write_bytes(b"aaa")
+    b.write_bytes(b"bbb")
+    c.write_bytes(b"ccc")
+    dest_loli = cats / "loli"
+    dest_shota = cats / "shota"
+
+    run_id = _seed_completed_run(
+        root,
+        cats,
+        [
+            {
+                "file_path": str(a),
+                "primary_tag": "loli",
+                "primary_score": 0.9,
+                "final_destination": str(dest_loli),
+                "status": "approved",
+            },
+            {
+                "file_path": str(b),
+                "primary_tag": "shota",
+                "primary_score": 0.85,
+                "final_destination": str(dest_shota),
+                "status": "proposed",
+            },
+            {
+                "file_path": str(c),
+                "primary_tag": "loli",
+                "primary_score": 0.7,
+                "final_destination": str(dest_loli),
+                "status": "rejected",
+            },
+        ],
+    )
+
+    with TestClient(app) as client:
+        resp = client.post(
+            f"/api/runs/{run_id}/migrate",
+            json={"mode": "copy", "create_missing_folders": True},
+        )
+        resp.raise_for_status()
+        payload = resp.json()
+        assert payload["total_candidates"] == 1
+        assert payload["migrated_count"] == 1
+        assert payload["failed_count"] == 0
+        assert (dest_loli / "a.jpg").is_file()
+        assert (dest_loli / "a.jpg").read_bytes() == b"aaa"
+        assert a.exists()  # copy keeps source
+        assert not (dest_shota / "b.jpg").exists()
+        assert not (dest_loli / "c.jpg").exists()
+
+        item = fetch_one("SELECT status, migrated_to FROM items WHERE file_path = ?", (str(a),))
+        assert item["status"] == "migrated"
+        assert item["migrated_to"].endswith("a.jpg")
+
+
+def test_migrate_move_removes_source(tmp_path: Path) -> None:
+    root = tmp_path / "root"
+    cats = tmp_path / "cats" / "NTR"
+    root.mkdir()
+    cats.mkdir(parents=True)
+    src = root / "ntr.jpg"
+    src.write_bytes(b"ntr-bytes")
+    run_id = _seed_completed_run(
+        root,
+        cats.parent,
+        [
+            {
+                "file_path": str(src),
+                "primary_tag": "NTR",
+                "primary_score": 0.8,
+                "final_destination": str(cats),
+                "status": "approved",
+            }
+        ],
+    )
+
+    with TestClient(app) as client:
+        resp = client.post(
+            f"/api/runs/{run_id}/migrate",
+            json={"mode": "move", "create_missing_folders": False},
+        )
+        resp.raise_for_status()
+        payload = resp.json()
+        assert payload["migrated_count"] == 1
+        assert not src.exists()
+        assert (cats / "ntr.jpg").read_bytes() == b"ntr-bytes"
+
+
+def test_migrate_collision_suffix(tmp_path: Path) -> None:
+    root = tmp_path / "root"
+    dest = tmp_path / "cats" / "furry"
+    root.mkdir()
+    dest.mkdir(parents=True)
+    src = root / "dup.jpg"
+    src.write_bytes(b"new")
+    (dest / "dup.jpg").write_bytes(b"old")
+    run_id = _seed_completed_run(
+        root,
+        dest.parent,
+        [
+            {
+                "file_path": str(src),
+                "primary_tag": "furry",
+                "final_destination": str(dest),
+                "status": "approved",
+            }
+        ],
+    )
+
+    with TestClient(app) as client:
+        resp = client.post(
+            f"/api/runs/{run_id}/migrate",
+            json={"mode": "copy", "create_missing_folders": True},
+        )
+        resp.raise_for_status()
+        assert resp.json()["migrated_count"] == 1
+        assert (dest / "dup.jpg").read_bytes() == b"old"
+        assert (dest / "dup_1.jpg").read_bytes() == b"new"
+
+
+def test_migrate_creates_taxonomy_folder(tmp_path: Path) -> None:
+    root = tmp_path / "root"
+    cats = tmp_path / "cats"
+    root.mkdir()
+    cats.mkdir()
+    src = root / "poke.webp"
+    src.write_bytes(b"poke")
+    dest = cats / "Pokemon"
+    run_id = _seed_completed_run(
+        root,
+        cats,
+        [
+            {
+                "file_path": str(src),
+                "primary_tag": "Pokemon",
+                "final_destination": str(dest),
+                "status": "approved",
+            }
+        ],
+    )
+
+    with TestClient(app) as client:
+        resp = client.post(
+            f"/api/runs/{run_id}/migrate",
+            json={"mode": "copy", "create_missing_folders": True},
+        )
+        resp.raise_for_status()
+        assert resp.json()["migrated_count"] == 1
+        assert dest.is_dir()
+        assert (dest / "poke.webp").is_file()
+
+
+def test_migrate_fails_missing_source_and_missing_destination(tmp_path: Path) -> None:
+    root = tmp_path / "root"
+    cats = tmp_path / "cats"
+    root.mkdir()
+    cats.mkdir()
+    missing = root / "gone.jpg"
+    present = root / "ok.jpg"
+    present.write_bytes(b"ok")
+    run_id = _seed_completed_run(
+        root,
+        cats,
+        [
+            {
+                "file_path": str(missing),
+                "primary_tag": "loli",
+                "final_destination": str(cats / "loli"),
+                "status": "approved",
+            },
+            {
+                "file_path": str(present),
+                "primary_tag": "loli",
+                "final_destination": None,
+                "status": "approved",
+            },
+        ],
+    )
+
+    with TestClient(app) as client:
+        resp = client.post(
+            f"/api/runs/{run_id}/migrate",
+            json={"mode": "copy", "create_missing_folders": True},
+        )
+        resp.raise_for_status()
+        payload = resp.json()
+        assert payload["total_candidates"] == 2
+        assert payload["migrated_count"] == 0
+        assert payload["failed_count"] == 2
+        errors = {r["error"] for r in payload["results"]}
+        assert any("does not exist" in (e or "") for e in errors)
+        assert any("No destination" in (e or "") for e in errors)
+
+
+def test_migrate_create_missing_folders_false_fails_when_absent(tmp_path: Path) -> None:
+    root = tmp_path / "root"
+    cats = tmp_path / "cats"
+    root.mkdir()
+    cats.mkdir()
+    src = root / "x.jpg"
+    src.write_bytes(b"x")
+    dest = cats / "incest"  # not created
+    run_id = _seed_completed_run(
+        root,
+        cats,
+        [
+            {
+                "file_path": str(src),
+                "primary_tag": "incest",
+                "final_destination": str(dest),
+                "status": "approved",
+            }
+        ],
+    )
+
+    with TestClient(app) as client:
+        resp = client.post(
+            f"/api/runs/{run_id}/migrate",
+            json={"mode": "copy", "create_missing_folders": False},
+        )
+        resp.raise_for_status()
+        payload = resp.json()
+        assert payload["migrated_count"] == 0
+        assert payload["failed_count"] == 1
+        assert not dest.exists()
+        assert "does not exist" in (payload["results"][0].get("error") or "").lower()
+
+
+def test_migrate_rejects_running_run(tmp_path: Path) -> None:
+    root = tmp_path / "root"
+    cats = tmp_path / "cats"
+    root.mkdir()
+    cats.mkdir()
+    run_id = _seed_completed_run(root, cats, [], status="running")
+    with TestClient(app) as client:
+        resp = client.post(
+            f"/api/runs/{run_id}/migrate",
+            json={"mode": "copy", "create_missing_folders": True},
+        )
+        assert resp.status_code == 409
+
+
+def test_migrate_idempotent_second_pass(tmp_path: Path) -> None:
+    root = tmp_path / "root"
+    dest = tmp_path / "cats" / "fellatio"
+    root.mkdir()
+    dest.mkdir(parents=True)
+    src = root / "f.jpg"
+    src.write_bytes(b"f")
+    run_id = _seed_completed_run(
+        root,
+        dest.parent,
+        [
+            {
+                "file_path": str(src),
+                "primary_tag": "fellatio",
+                "final_destination": str(dest),
+                "status": "approved",
+            }
+        ],
+    )
+    with TestClient(app) as client:
+        first = client.post(
+            f"/api/runs/{run_id}/migrate",
+            json={"mode": "copy", "create_missing_folders": True},
+        )
+        first.raise_for_status()
+        assert first.json()["migrated_count"] == 1
+        second = client.post(
+            f"/api/runs/{run_id}/migrate",
+            json={"mode": "copy", "create_missing_folders": True},
+        )
+        second.raise_for_status()
+        assert second.json()["total_candidates"] == 0
+        assert second.json()["migrated_count"] == 0
+
+
+def test_approve_then_migrate_end_to_end(tmp_path: Path) -> None:
+    root = tmp_path / "root"
+    cats = tmp_path / "cats"
+    root.mkdir()
+    cats.mkdir()
+    src = root / "review_me.jpg"
+    src.write_bytes(b"rev")
+    dest = cats / "nakadashi"
+    run_id = _seed_completed_run(
+        root,
+        cats,
+        [
+            {
+                "file_path": str(src),
+                "primary_tag": "nakadashi",
+                "primary_score": 0.55,
+                "suggested_destination": str(dest),
+                "final_tag": "nakadashi",
+                "final_destination": str(dest),
+                "status": "proposed",
+                "needs_review": True,
+                "review_reason": "Below threshold",
+            }
+        ],
+    )
+    item = fetch_one("SELECT id FROM items WHERE run_id = ?", (run_id,))
+    with TestClient(app) as client:
+        patch = client.patch(f"/api/items/{item['id']}", json={"status": "approved"})
+        patch.raise_for_status()
+        assert patch.json()["status"] == "approved"
+        mig = client.post(
+            f"/api/runs/{run_id}/migrate",
+            json={"mode": "copy", "create_missing_folders": True},
+        )
+        mig.raise_for_status()
+        assert mig.json()["migrated_count"] == 1
+        assert (dest / "review_me.jpg").is_file()

backend/tests/test_classify_accuracy.py

@@ -0,0 +1,118 @@
+"""Accuracy audit for taxonomy routing + classify gates (score fixtures)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from PIL import Image
+
+from app.api import _classify_from_scores
+from app.taxonomy import choose_best_destination, reload_taxonomy
+
+
+SELECTED_ALL = {
+    "fertilization",
+    "NTR",
+    "incest",
+    "nakadashi",
+    "fellatio",
+    "loli",
+    "shota",
+    "monster_girl",
+    "furry",
+    "Pokemon",
+}
+
+
+@pytest.fixture(autouse=True)
+def _reload_default_taxonomy() -> None:
+    reload_taxonomy()
+
+
+@pytest.mark.parametrize(
+    "scores,expected",
+    [
+        ({"loli": 0.92, "flat_chest": 0.99, "lolita_fashion": 0.95}, "loli"),
+        ({"shota": 0.88, "1boy": 0.99, "child": 0.9}, "shota"),
+        ({"netorare": 0.81, "caught": 0.99}, "NTR"),
+        ({"incest": 0.77, "siblings": 0.99}, "incest"),
+        ({"internal_cumshot": 0.9, "cum_in_pussy": 0.95}, "nakadashi"),
+        ({"fertilization": 0.8, "cum_in_pussy": 0.99}, "fertilization"),
+        ({"impregnation": 0.85, "pregnant": 0.99}, "fertilization"),
+        ({"irrumatio": 0.9}, "fellatio"),
+        ({"monster_girl": 0.9, "horns": 0.99, "wings": 0.98}, "monster_girl"),
+        ({"slime_girl": 0.86}, "monster_girl"),
+        ({"furry": 0.9, "animal_ears": 0.99}, "furry"),
+        ({"pokemon_(creature)": 0.91, "pokemon_ears": 0.99}, "Pokemon"),
+        # False-positive clusters must not route
+        ({"lolita_fashion": 0.99, "gothic_lolita": 0.98, "flat_chest": 0.97}, None),
+        ({"1boy": 0.99, "male_focus": 0.98, "otoko_no_ko": 0.9}, None),
+        ({"animal_ears": 0.99, "fake_animal_ears": 0.9}, None),
+        ({"siblings": 0.99}, None),
+        ({"pregnant": 0.99}, None),
+        ({"voyeurism": 0.99, "caught": 0.9}, None),
+        ({"horns": 0.99, "wings": 0.98, "tail": 0.97}, None),
+        ({"oral": 0.99}, None),
+    ],
+)
+def test_taxonomy_routing_matrix(scores: dict[str, float], expected: str | None) -> None:
+    folder, _score, _secondary = choose_best_destination(scores, SELECTED_ALL)
+    assert folder == expected
+
+
+def test_classify_gate_clears_weak_taxonomy_winner(tmp_path: Path) -> None:
+    result = _classify_from_scores(
+        tmp_path / "x.jpg",
+        {"loli": 0.2, "1girl": 0.99},
+        {"loli", "shota"},
+        confidence_threshold=0.6,
+    )
+    assert result.primary_tag is None
+    assert result.needs_review is True
+    assert result.secondary[0]["tag"] == "loli"
+
+
+def test_classify_assigns_strong_taxonomy_winner(tmp_path: Path) -> None:
+    result = _classify_from_scores(
+        tmp_path / "x.jpg",
+        {"loli": 0.91, "flat_chest": 0.95, "shota": 0.4},
+        {"loli", "shota", "furry"},
+        confidence_threshold=0.6,
+    )
+    assert result.primary_tag == "loli"
+    assert result.primary_score == 0.91
+    assert result.needs_review is False
+
+
+def test_priority_fertilization_over_nakadashi_on_tie(tmp_path: Path) -> None:
+    result = _classify_from_scores(
+        tmp_path / "x.jpg",
+        {"fertilization": 0.8, "internal_cumshot": 0.8},
+        {"fertilization", "nakadashi"},
+        confidence_threshold=0.6,
+    )
+    assert result.primary_tag == "fertilization"
+
+
+def test_model_smoke_nonempty_scores_all_taggers(tmp_path: Path) -> None:
+    """Smoke: each tagger returns a non-empty score dict on a tiny RGB image.
+
+    This is not semantic accuracy (no labels); it catches broken sessions /
+    empty-output regressions across models.
+    """
+    pytest.importorskip("imgutils")
+    from app.services import extract_scores
+
+    img = tmp_path / "probe.png"
+    Image.new("RGB", (448, 448), color=(180, 120, 160)).save(img)
+
+    models = ["ml_danbooru", "wd_swinv2_v3", "wd_eva02_large"]
+    for model in models:
+        try:
+            scores = extract_scores(img, tagger_model=model, wd_general_threshold=0.35)
+        except Exception as err:  # pragma: no cover - environment-specific
+            pytest.skip(f"tagger {model} unavailable: {err}")
+        assert isinstance(scores, dict)
+        assert len(scores) > 0, f"{model} returned empty scores"
+        assert all(0.0 <= float(v) <= 1.0 for v in scores.values())